@displaydev/cli 0.18.0 → 0.20.0

package/dist/update-notice.js

@@ -0,0 +1,488 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Update-notification surface for `@displaydev/cli`. Two paths consume it:
+ * plain CLI (stderr block printed from a `process.on('exit', ...)` hook)
+ * and MCP stdio (content block appended to the next `tools/call` result).
+ *
+ * Module-level state (`latestVersion`, `injectedThisProcess`,
+ * `currentVersion`) is intentional. Tests reset between cases via
+ * `vi.resetModules()` + dynamic re-import — there is no exported
+ * test-only reset.
+ */ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export var PACKAGE_NAME = '@displaydev/cli';
+var NOTICE_PREFIX = '[displaydev]';
+var THROTTLE_MS = 24 * 60 * 60 * 1000;
+var latestVersion = null;
+var injectedThisProcess = false;
+var currentVersion = null;
+var mcpMode = false;
+/**
+ * Stamp the running CLI's version. main.ts calls this once at module
+ * scope; the value is read by `emitOnExit` and `injectIntoToolResult`
+ * when they format the notice text.
+ */ export function setCurrentVersion(version) {
+    currentVersion = version;
+}
+/**
+ * Mark this process as a long-running MCP-stdio server. main.ts calls
+ * this from the `mcp` subcommand handler. Once set, `emitOnExit` skips —
+ * MCP mode surfaces the notice via `injectIntoToolResult`, and the
+ * stderr fallback would (a) write the wrong text variant ("npm i -g"
+ * vs. "bump the host config") and (b) reach nowhere useful since stdio
+ * MCP hosts do not surface stderr to the agent.
+ */ export function setMcpMode() {
+    mcpMode = true;
+}
+/** Mark the CLI outdated, capturing the registry's `latest` value. */ export function markOutdated(version) {
+    latestVersion = version;
+}
+/** Read the most recently observed `latest`, or null. */ export function getLatestVersion() {
+    return latestVersion;
+}
+function statePath() {
+    return join(homedir(), '.displaydev', 'update-state.json');
+}
+/** Read the per-machine throttle state. Missing or corrupt → empty. */ export function loadUpdateState() {
+    try {
+        var raw = readFileSync(statePath(), 'utf-8');
+        var parsed = JSON.parse(raw);
+        if (parsed && (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object') {
+            return parsed;
+        }
+        return {};
+    } catch (unused) {
+        return {};
+    }
+}
+/** Persist the throttle state. Best-effort; failures swallow. */ export function saveUpdateState(state) {
+    try {
+        var path = statePath();
+        mkdirSync(dirname(path), {
+            recursive: true
+        });
+        writeFileSync(path, "".concat(JSON.stringify(state), "\n"));
+    } catch (unused) {
+    // Best-effort per spec failure-modes table — a write that fails
+    // means we re-fire next invocation, which is preferable to a
+    // crash on read-only home or a full disk.
+    }
+}
+/**
+ * Compare two semver strings; returns true when `a > b`. Implements the
+ * pre-release ranking rules from semver.org §11:
+ *   - Numeric identifiers compare numerically.
+ *   - Alphanumeric identifiers compare lexically (ASCII).
+ *   - Numeric identifiers always rank below alphanumeric.
+ *   - A longer pre-release identifier list outranks a prefix-equal shorter
+ *     one (e.g. `0.20.0-alpha.1` > `0.20.0-alpha`).
+ *   - A stable release outranks any pre-release with the same `x.y.z`.
+ *
+ * Returns false for anything that fails to parse.
+ */ export function semverGt(a, b) {
+    // Strict semver (semver.org §9): numeric identifiers MUST NOT have
+    // leading zeros, identifiers MUST NOT be empty.
+    var NUMERIC_RE = /^(?:0|[1-9]\d*)$/;
+    var ALPHANUM_RE = /^[0-9A-Za-z-]+$/;
+    var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+    var isValidPreId = function isValidPreId(id) {
+        if (id.length === 0) {
+            return false;
+        }
+        // Numeric identifier with leading zeros is invalid (`-01`, `-007`).
+        if (/^\d+$/.test(id) && id.length > 1 && id.startsWith('0')) {
+            return false;
+        }
+        return ALPHANUM_RE.test(id);
+    };
+    var parsed = function parsed(v) {
+        var match = SEMVER_RE.exec(v);
+        if (!match) {
+            return null;
+        }
+        // Reject leading zeros on the numeric main triple too (`01.0.0`).
+        if (![
+            match[1],
+            match[2],
+            match[3]
+        ].every(function(p) {
+            return NUMERIC_RE.test(p);
+        })) {
+            return null;
+        }
+        var preIds = match[4] ? match[4].split('.') : [];
+        if (!preIds.every(isValidPreId)) {
+            return null;
+        }
+        return {
+            parts: [
+                Number(match[1]),
+                Number(match[2]),
+                Number(match[3])
+            ],
+            preIds: preIds
+        };
+    };
+    var A = parsed(a);
+    var B = parsed(b);
+    if (!A || !B) {
+        return false;
+    }
+    for(var i = 0; i < 3; i++){
+        if (A.parts[i] !== B.parts[i]) {
+            return A.parts[i] > B.parts[i];
+        }
+    }
+    // Equal main parts: stable release outranks any pre-release.
+    if (A.preIds.length === 0 && B.preIds.length > 0) {
+        return true;
+    }
+    if (A.preIds.length > 0 && B.preIds.length === 0) {
+        return false;
+    }
+    var len = Math.min(A.preIds.length, B.preIds.length);
+    for(var i1 = 0; i1 < len; i1++){
+        var cmp = comparePreId(A.preIds[i1], B.preIds[i1]);
+        if (cmp !== 0) {
+            return cmp > 0;
+        }
+    }
+    // All shared identifiers equal: longer list ranks higher.
+    return A.preIds.length > B.preIds.length;
+}
+/**
+ * Compare two pre-release identifiers per semver §11.4. Numeric < alphanumeric;
+ * pure-numeric identifiers compare numerically; alphanumerics compare lexically.
+ * Returns positive when `a > b`, negative when `a < b`, 0 when equal.
+ */ function comparePreId(a, b) {
+    var numA = /^\d+$/.test(a);
+    var numB = /^\d+$/.test(b);
+    if (numA && numB) {
+        var na = Number(a);
+        var nb = Number(b);
+        return na === nb ? 0 : na > nb ? 1 : -1;
+    }
+    if (numA) {
+        return -1;
+    }
+    if (numB) {
+        return 1;
+    }
+    return a === b ? 0 : a > b ? 1 : -1;
+}
+/**
+ * Read `X-Client-Latest-Version` from a Response and, when greater than
+ * the local CLI version, mark the comparator outdated. Silently skips
+ * missing / blank / malformed values.
+ */ export function readLatestVersionFromResponse(res, current) {
+    var header = res.headers.get('x-client-latest-version');
+    if (!header) {
+        return;
+    }
+    var trimmed = header.trim();
+    if (!trimmed) {
+        return;
+    }
+    if (semverGt(trimmed, current)) {
+        markOutdated(trimmed);
+    }
+}
+export function formatNotice(opts) {
+    // Single-line dimmed banner for humans in a terminal — mode === 'cli'
+    // is the only path that ever sees `tty === true` (MCP is always stdio).
+    if (opts.mode === 'cli' && opts.tty) {
+        var dim = '\x1b[2m';
+        var reset = '\x1b[0m';
+        return "".concat(dim).concat(NOTICE_PREFIX, " update available: ").concat(opts.latest, " (you have ").concat(opts.current, "). Run `npm i -g ").concat(PACKAGE_NAME, "@latest` to update.").concat(reset);
+    }
+    if (opts.mode === 'cli') {
+        return [
+            "".concat(NOTICE_PREFIX, " Update available: ").concat(PACKAGE_NAME, " ").concat(opts.latest, " (you have ").concat(opts.current, ")."),
+            'Ask the user if they want to update.',
+            "If yes: run `npm i -g ".concat(PACKAGE_NAME, "@latest` (or the equivalent for their package manager — bun, pnpm, yarn — based on how they installed it) and retry the original command.")
+        ].join('\n');
+    }
+    // MCP variant: npm i -g does not update an already-running stdio
+    // process; the host has to bump its config and restart.
+    return [
+        "".concat(NOTICE_PREFIX, " Update available: ").concat(PACKAGE_NAME, " ").concat(opts.latest, " (you have ").concat(opts.current, ")."),
+        'Ask the user if they want to update.',
+        "If yes: bump the version pin for ".concat(PACKAGE_NAME, " in their MCP host config, or if the config uses @latest, ask them to restart their MCP host.")
+    ].join('\n');
+}
+function passesThrottle(now, state) {
+    if (!state.lastNoticeAt) {
+        return true;
+    }
+    var last = Date.parse(state.lastNoticeAt);
+    if (Number.isNaN(last)) {
+        return true;
+    }
+    return now - last >= THROTTLE_MS;
+}
+/**
+ * Synchronous `'exit'` handler for plain CLI mode. Fires after every
+ * termination path (natural completion, `process.exit(N)`, uncaught
+ * exception). Must remain synchronous — the event loop is winding
+ * down by the time it runs, so `await` would silently no-op.
+ *
+ * Skips when the process is running as a stdio MCP server (notice text
+ * differs and stderr is not surfaced to the host) or when injection has
+ * already fired in this process (MCP mode already prompted via the
+ * tool-result content block).
+ */ export function emitOnExit() {
+    if (mcpMode) {
+        return;
+    }
+    if (injectedThisProcess) {
+        return;
+    }
+    if (latestVersion === null || currentVersion === null) {
+        return;
+    }
+    var state = loadUpdateState();
+    var now = Date.now();
+    if (!passesThrottle(now, state)) {
+        return;
+    }
+    var text = formatNotice({
+        current: currentVersion,
+        latest: latestVersion,
+        mode: 'cli',
+        tty: Boolean(process.stderr.isTTY)
+    });
+    process.stderr.write("".concat(text, "\n"));
+    saveUpdateState({
+        lastNoticeAt: new Date(now).toISOString(),
+        lastNoticeVersion: latestVersion
+    });
+}
+/**
+ * Append a notice content block to a tool-call result when:
+ *   1. The comparator has marked the CLI outdated.
+ *   2. We have not already injected once in this process.
+ *   3. The cross-process 24 h throttle allows.
+ *
+ * Preserves `_meta`, `isError`, and any other top-level fields. Only
+ * `content` changes shape (a new entry appended).
+ */ export function injectIntoToolResult(result) {
+    if (latestVersion === null || currentVersion === null) {
+        return result;
+    }
+    if (injectedThisProcess) {
+        return result;
+    }
+    var now = Date.now();
+    var state = loadUpdateState();
+    if (!passesThrottle(now, state)) {
+        return result;
+    }
+    var text = formatNotice({
+        current: currentVersion,
+        latest: latestVersion,
+        mode: 'mcp',
+        tty: false
+    });
+    result.content = _to_consumable_array(result.content).concat([
+        {
+            type: 'text',
+            text: text
+        }
+    ]);
+    injectedThisProcess = true;
+    saveUpdateState({
+        lastNoticeAt: new Date(now).toISOString(),
+        lastNoticeVersion: latestVersion
+    });
+    return result;
+}
+/**
+ * Higher-order wrapper around an MCP tool handler. Awaits the inner
+ * handler then runs the result through `injectIntoToolResult`.
+ *
+ * Mounted in `mcp-server.ts` at every `server.tool(...)` registration
+ * site so injection runs uniformly regardless of which return shape
+ * (`okResponse` / `errorResponse` / direct literal / `_meta`-bearing)
+ * the inner handler returned.
+ */ export function withUpdateNotice(handler) {
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return _async_to_generator(function() {
+            var result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            handler.apply(void 0, _to_consumable_array(args))
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            injectIntoToolResult(result)
+                        ];
+                }
+            });
+        })();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displaydev/cli",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "type": "module",
   "bin": {
     "dsp": "dist/main.js"