@wingman-ai/gateway 0.5.4 → 0.6.0

package/dist/cli/core/sessionManager.js

@@ -448,29 +448,52 @@ function toSessionMessage(entry, index, baseTime) {
     if ("user" !== role && "assistant" !== role) {
         if (isToolMessage(entry)) {
             const blocks = extractContentBlocks(entry);
-            const toolContent = extractMessageContent(entry, blocks);
-            const ui = extractUiFromPayload(toolContent);
+            const toolResult = extractPersistedToolResult(entry, index);
+            if (!toolResult) return null;
+            const { ui, uiOnly, textFallback, data: toolOutput } = splitPersistedToolPayload(toolResult.output);
             const attachments = extractAttachments(blocks);
-            if (ui?.spec || attachments.length > 0) {
-                const content = toolContent || ui?.textFallback || "";
-                return {
-                    id: `msg-${index}`,
-                    role: "assistant",
-                    content,
-                    attachments: attachments.length > 0 ? attachments : void 0,
-                    createdAt: baseTime + index,
-                    ...ui?.spec ? {
-                        uiBlocks: [
-                            {
-                                spec: ui.spec,
-                                uiOnly: ui.uiOnly,
-                                textFallback: ui.textFallback
-                            }
-                        ],
-                        uiTextFallback: ui.textFallback
-                    } : {}
-                };
-            }
+            const eventTimestamp = baseTime + index;
+            return {
+                id: `msg-${index}`,
+                role: "assistant",
+                content: "",
+                attachments: attachments.length > 0 ? attachments : void 0,
+                toolEvents: [
+                    {
+                        id: toolResult.id,
+                        name: toolResult.name || "tool",
+                        status: toolResult.error ? "error" : "completed",
+                        output: toolOutput,
+                        ui,
+                        uiOnly,
+                        textFallback,
+                        error: toolResult.error,
+                        timestamp: eventTimestamp,
+                        startedAt: eventTimestamp,
+                        completedAt: eventTimestamp
+                    }
+                ],
+                activityTimeline: [
+                    {
+                        id: `tl-tool-${toolResult.id}`,
+                        kind: "tool",
+                        order: eventTimestamp,
+                        toolEventId: toolResult.id
+                    }
+                ],
+                createdAt: eventTimestamp,
+                ...ui ? {
+                    uiBlocks: [
+                        {
+                            id: toolResult.id,
+                            spec: ui,
+                            uiOnly,
+                            textFallback
+                        }
+                    ],
+                    uiTextFallback: textFallback
+                } : {}
+            };
         }
         return null;
     }
@@ -641,6 +664,44 @@ function isTextLikeContentType(type) {
     const normalized = type.toLowerCase();
     return "text" === normalized || "input_text" === normalized || "output_text" === normalized || "text_delta" === normalized;
 }
+function extractPersistedToolResult(entry, index) {
+    const toolCallId = entry?.tool_call_id ?? entry?.kwargs?.tool_call_id ?? entry?.additional_kwargs?.tool_call_id ?? ("string" == typeof entry?.id ? entry.id : null) ?? ("string" == typeof entry?.kwargs?.id ? entry.kwargs.id : null) ?? ("string" == typeof entry?.additional_kwargs?.id ? entry.additional_kwargs.id : null) ?? `tool-${index}`;
+    if (!toolCallId) return null;
+    return {
+        id: String(toolCallId),
+        name: entry?.name ?? entry?.kwargs?.name ?? entry?.additional_kwargs?.name,
+        output: entry?.content ?? entry?.kwargs?.content ?? "",
+        error: entry?.kwargs?.error ?? entry?.additional_kwargs?.error
+    };
+}
+function splitPersistedToolPayload(payload) {
+    if ("string" == typeof payload) try {
+        const parsed = JSON.parse(payload);
+        if (parsed && "object" == typeof parsed) return splitPersistedToolPayload(parsed);
+    } catch  {
+        return {
+            data: payload
+        };
+    }
+    if (!payload || "object" != typeof payload) return {
+        data: payload
+    };
+    if (!("ui" in payload)) {
+        const content = "string" == typeof payload.content ? payload.content : "string" == typeof payload?.kwargs?.content ? payload.kwargs.content : null;
+        if (content) return splitPersistedToolPayload(content);
+        return {
+            data: payload
+        };
+    }
+    const { ui, uiOnly, textFallback, ...rest } = payload;
+    const validUi = ui && "object" == typeof ui && Array.isArray(ui.components) ? ui : void 0;
+    return {
+        ui: validUi,
+        uiOnly: "boolean" == typeof uiOnly ? uiOnly : void 0,
+        textFallback: "string" == typeof textFallback ? textFallback : void 0,
+        data: validUi ? rest : payload
+    };
+}
 function isToolMessage(entry) {
     if (!entry || "object" != typeof entry) return false;
     const role = entry.role || entry?.kwargs?.role || entry?.additional_kwargs?.role;
@@ -657,9 +718,9 @@ function filterUiOnlyAssistantMessages(messages) {
             const blocks = extractContentBlocks(entry);
             const content = extractMessageContent(entry, blocks);
             const ui = extractUiFromPayload(content);
-            const attachments = extractAttachments(blocks);
+            extractAttachments(blocks);
             if (ui?.uiOnly && ui?.textFallback) pendingFallback = ui.textFallback.trim();
-            if (ui?.spec || attachments.length > 0) filtered.push(entry);
+            filtered.push(entry);
             continue;
         }
         const role = resolveMessageRole(entry);
@@ -753,7 +814,7 @@ function extractImageUrl(block) {
     }
     if ("resource_link" === block.type) {
         const mimeType = "string" == typeof block.mimeType ? block.mimeType.trim().toLowerCase() : "";
-        const uri = "string" == typeof block.uri ? block.uri.trim() : "";
+        const uri = normalizeLocalAttachmentUrl("string" == typeof block.uri ? block.uri.trim() : "");
         if (uri && (!mimeType || mimeType.startsWith("image/"))) return uri;
     }
     if ("resource" === block.type && block.resource) {
@@ -761,7 +822,8 @@ function extractImageUrl(block) {
         const mimeType = "string" == typeof resource.mimeType ? resource.mimeType.trim().toLowerCase() : "";
         if (!mimeType || !mimeType.startsWith("image/")) return null;
         if ("string" == typeof resource.blob && resource.blob.trim()) return `data:${mimeType};base64,${resource.blob.trim()}`;
-        if ("string" == typeof resource.uri && resource.uri.trim()) return resource.uri.trim();
+        const normalizedUri = normalizeLocalAttachmentUrl("string" == typeof resource.uri ? resource.uri.trim() : "");
+        if (normalizedUri) return normalizedUri;
     }
     return null;
 }
@@ -804,8 +866,103 @@ function parseDataUrlMime(dataUrl) {
 function extractString(...values) {
     for (const value of values)if ("string" == typeof value && value.trim().length > 0) return value.trim();
 }
+function normalizeLocalAttachmentUrl(value) {
+    const trimmed = extractString(value);
+    if (!trimmed) return;
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("data:") || trimmed.startsWith("blob:") || trimmed.startsWith("/api/fs/file?")) return trimmed;
+    const filesystemPath = extractLocalFilesystemPath(trimmed);
+    if (!filesystemPath) return trimmed;
+    return `/api/fs/file?path=${encodeURIComponent(filesystemPath)}`;
+}
+function extractLocalFilesystemPath(value) {
+    if (value.startsWith("file://")) try {
+        const parsed = new URL(value);
+        let pathname = decodeURIComponent(parsed.pathname || "");
+        if (!pathname) return null;
+        if (/^\/[A-Za-z]:[\\/]/.test(pathname)) pathname = pathname.slice(1);
+        if (parsed.host && !/^[A-Za-z]:[\\/]/.test(pathname)) return `//${parsed.host}${pathname}`;
+        return pathname;
+    } catch  {
+        return null;
+    }
+    if (/^[A-Za-z]:[\\/]/.test(value)) return value;
+    if (value.startsWith("/") && !value.startsWith("//") && !value.startsWith("/api/")) return value;
+    return null;
+}
 function extractFileAttachment(block) {
     if (!block || "object" != typeof block) return null;
+    if ("resource_link" === block.type) {
+        const uri = normalizeLocalAttachmentUrl(extractString(block.uri));
+        if (!uri) return null;
+        return {
+            kind: "file",
+            dataUrl: uri,
+            name: extractString(block.name),
+            mimeType: extractString(block.mimeType)
+        };
+    }
+    if ("resource" === block.type && block.resource) {
+        const resource = "object" == typeof block.resource ? block.resource : null;
+        if (!resource) return null;
+        const mimeType = extractString(resource.mimeType);
+        const blob = extractString(resource.blob);
+        const uri = extractString(resource.uri);
+        const name = extractString(resource.name, block.name);
+        if (blob && mimeType) return {
+            kind: "file",
+            dataUrl: `data:${mimeType};base64,${blob}`,
+            name,
+            mimeType
+        };
+        const normalizedUri = normalizeLocalAttachmentUrl(uri);
+        if (normalizedUri) return {
+            kind: "file",
+            dataUrl: normalizedUri,
+            name,
+            mimeType
+        };
+    }
+    if ("video" === block.type) {
+        const sourceType = block.source_type || block.sourceType;
+        const mimeType = extractString(block.mime_type, block.mimeType, block.media_type, block.mediaType) || "video/webm";
+        const name = extractString(block.name, block.filename);
+        if ("base64" === sourceType && "string" == typeof block.data) return {
+            kind: "file",
+            dataUrl: `data:${mimeType};base64,${block.data}`,
+            name,
+            mimeType
+        };
+        if ("url" === sourceType && "string" == typeof block.url) {
+            const normalizedUrl = normalizeLocalAttachmentUrl(block.url);
+            if (!normalizedUrl) return null;
+            return {
+                kind: "file",
+                dataUrl: normalizedUrl,
+                name,
+                mimeType
+            };
+        }
+        if (block.source && "object" == typeof block.source) {
+            const source = block.source;
+            const sourceMimeType = extractString(source.media_type, source.mediaType, mimeType);
+            if ("string" == typeof source.data && sourceMimeType) return {
+                kind: "file",
+                dataUrl: `data:${sourceMimeType};base64,${source.data}`,
+                name,
+                mimeType: sourceMimeType
+            };
+            if ("string" == typeof source.url) {
+                const normalizedUrl = normalizeLocalAttachmentUrl(source.url);
+                if (!normalizedUrl) return null;
+                return {
+                    kind: "file",
+                    dataUrl: normalizedUrl,
+                    name,
+                    mimeType: sourceMimeType
+                };
+            }
+        }
+    }
     if ("file" === block.type) {
         const sourceType = block.source_type || block.sourceType;
         const metadata = block.metadata && "object" == typeof block.metadata ? block.metadata : {};
@@ -821,10 +978,12 @@ function extractFileAttachment(block) {
             };
         }
         if ("url" === sourceType && "string" == typeof block.url) {
-            const mimeType = declaredMime || parseDataUrlMime(block.url);
+            const normalizedUrl = normalizeLocalAttachmentUrl(block.url);
+            if (!normalizedUrl) return null;
+            const mimeType = declaredMime || parseDataUrlMime(normalizedUrl);
             return {
                 kind: "file",
-                dataUrl: block.url,
+                dataUrl: normalizedUrl,
                 name,
                 mimeType
             };
@@ -840,12 +999,16 @@ function extractFileAttachment(block) {
                 name: fileName,
                 mimeType: parseDataUrlMime(fileData)
             };
-            if (fileUrl) return {
-                kind: "file",
-                dataUrl: fileUrl,
-                name: fileName,
-                mimeType: parseDataUrlMime(fileUrl)
-            };
+            if (fileUrl) {
+                const normalizedUrl = normalizeLocalAttachmentUrl(fileUrl);
+                if (!normalizedUrl) return null;
+                return {
+                    kind: "file",
+                    dataUrl: normalizedUrl,
+                    name: fileName,
+                    mimeType: parseDataUrlMime(normalizedUrl)
+                };
+            }
         }
     }
     if ("input_file" === block.type) {
@@ -871,12 +1034,16 @@ function extractFileAttachment(block) {
                 mimeType
             };
         }
-        if ("url" === sourceType && "string" == typeof source.url) return {
-            kind: "file",
-            dataUrl: source.url,
-            name,
-            mimeType: parseDataUrlMime(source.url)
-        };
+        if ("url" === sourceType && "string" == typeof source.url) {
+            const normalizedUrl = normalizeLocalAttachmentUrl(source.url);
+            if (!normalizedUrl) return null;
+            return {
+                kind: "file",
+                dataUrl: normalizedUrl,
+                name,
+                mimeType: parseDataUrlMime(normalizedUrl)
+            };
+        }
     }
     return null;
 }
@@ -939,7 +1106,7 @@ function scoreMessages(candidate, baseTime) {
     };
 }
 function filterEmptyAssistantMessages(messages) {
-    const filtered = messages.filter((message)=>"assistant" !== message.role || message.content.trim().length > 0 || (message.attachments?.length ?? 0) > 0 || Array.isArray(message.uiBlocks) && message.uiBlocks.length > 0);
+    const filtered = messages.filter((message)=>"assistant" !== message.role || message.content.trim().length > 0 || (message.attachments?.length ?? 0) > 0 || (message.uiBlocks?.length ?? 0) > 0 || (message.toolEvents?.length ?? 0) > 0 || (message.activityTimeline?.length ?? 0) > 0);
     return filtered.length > 0 ? filtered : messages;
 }
 export { SessionManager, extractAttachments, extractImageAttachments, extractImageUrl, extractMessagesFromState, resolveMessageRole };

package/dist/cli/index.cjs

@@ -12,6 +12,7 @@ const skill_cjs_namespaceObject = require("./commands/skill.cjs");
 const loader_cjs_namespaceObject = require("./config/loader.cjs");
 const outputManager_cjs_namespaceObject = require("./core/outputManager.cjs");
 const workspace_cjs_namespaceObject = require("./core/workspace.cjs");
+const updateCheck_cjs_namespaceObject = require("./services/updateCheck.cjs");
 function parseArgs(argv) {
     const args = argv.slice(2);
     if (args.includes("--help") || args.includes("-h")) return {
@@ -149,6 +150,11 @@ For gateway help:
   wingman gateway --help
   `);
 }
+function showCliUpdateNotice(notice) {
+    console.warn(`Update available for Wingman: ${notice.currentVersion} -> ${notice.latestVersion}`);
+    console.warn(`Upgrade with: ${notice.command}`);
+    console.warn("");
+}
 async function main() {
     try {
         const parsed = parseArgs(process.argv);
@@ -163,6 +169,15 @@ async function main() {
         let outputMode;
         outputMode = "interactive" === parsed.outputMode || "json" === parsed.outputMode ? parsed.outputMode : "auto" === config.cli.outputMode ? outputManager_cjs_namespaceObject.OutputManager.detectMode() : config.cli.outputMode;
         const verbosity = determineVerbosity(parsed.verbosity, config.logLevel);
+        const logger = (0, external_logger_cjs_namespaceObject.createLogger)(verbosity);
+        if ("interactive" === outputMode && !process.env.CI) {
+            const updateNotice = await (0, updateCheck_cjs_namespaceObject.checkForCliUpdate)({
+                workspace,
+                configDir,
+                logger
+            });
+            if (updateNotice) showCliUpdateNotice(updateNotice);
+        }
         if ("agent" === parsed.command) {
             const commandArgs = {
                 agent: parsed.agent || config.defaultAgent,
@@ -239,7 +254,7 @@ async function main() {
             });
         } else {
             const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
-            (0, external_logger_cjs_namespaceObject.createLogger)(verbosity).error(`Unknown command: ${parsed.command}`);
+            logger.error(`Unknown command: ${parsed.command}`);
             console.error(`Unknown command: ${parsed.command}`);
             console.error('Run "wingman --help" for usage information');
             console.error(`Logs: ${logFile}`);

package/dist/cli/index.js

@@ -10,6 +10,7 @@ import { executeSkillCommand } from "./commands/skill.js";
 import { WingmanConfigLoader } from "./config/loader.js";
 import { OutputManager } from "./core/outputManager.js";
 import { resolveWorkspaceRoot } from "./core/workspace.js";
+import { checkForCliUpdate } from "./services/updateCheck.js";
 function parseArgs(argv) {
     const args = argv.slice(2);
     if (args.includes("--help") || args.includes("-h")) return {
@@ -147,6 +148,11 @@ For gateway help:
   wingman gateway --help
   `);
 }
+function showCliUpdateNotice(notice) {
+    console.warn(`Update available for Wingman: ${notice.currentVersion} -> ${notice.latestVersion}`);
+    console.warn(`Upgrade with: ${notice.command}`);
+    console.warn("");
+}
 async function main() {
     try {
         const parsed = parseArgs(process.argv);
@@ -161,6 +167,15 @@ async function main() {
         let outputMode;
         outputMode = "interactive" === parsed.outputMode || "json" === parsed.outputMode ? parsed.outputMode : "auto" === config.cli.outputMode ? OutputManager.detectMode() : config.cli.outputMode;
         const verbosity = determineVerbosity(parsed.verbosity, config.logLevel);
+        const logger = createLogger(verbosity);
+        if ("interactive" === outputMode && !process.env.CI) {
+            const updateNotice = await checkForCliUpdate({
+                workspace,
+                configDir,
+                logger
+            });
+            if (updateNotice) showCliUpdateNotice(updateNotice);
+        }
         if ("agent" === parsed.command) {
             const commandArgs = {
                 agent: parsed.agent || config.defaultAgent,
@@ -237,7 +252,7 @@ async function main() {
             });
         } else {
             const logFile = getLogFilePath();
-            createLogger(verbosity).error(`Unknown command: ${parsed.command}`);
+            logger.error(`Unknown command: ${parsed.command}`);
             console.error(`Unknown command: ${parsed.command}`);
             console.error('Run "wingman --help" for usage information');
             console.error(`Logs: ${logFile}`);

package/dist/cli/services/updateCheck.cjs

@@ -0,0 +1,212 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveCliUpdateCheckCachePath: ()=>resolveCliUpdateCheckCachePath,
+    compareCliVersions: ()=>compareCliVersions,
+    loadCliPackageMetadata: ()=>loadCliPackageMetadata,
+    checkForCliUpdate: ()=>checkForCliUpdate
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const DEFAULT_TIMEOUT_MS = 1500;
+const DEFAULT_CACHE_TTL_MS = 43200000;
+async function loadCliPackageMetadata(packageJsonUrl = new URL("../../../package.json", __rslib_import_meta_url__)) {
+    try {
+        const raw = await (0, promises_namespaceObject.readFile)(packageJsonUrl, "utf-8");
+        const parsed = JSON.parse(raw);
+        if ("string" != typeof parsed.name || "string" != typeof parsed.version) return null;
+        const name = parsed.name.trim();
+        const version = parsed.version.trim();
+        if (!name || !version) return null;
+        return {
+            name,
+            version
+        };
+    } catch  {
+        return null;
+    }
+}
+function compareCliVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) return 0;
+    for(let index = 0; index < parsedLeft.core.length; index++){
+        const diff = parsedLeft.core[index] - parsedRight.core[index];
+        if (0 !== diff) return diff;
+    }
+    return comparePrerelease(parsedLeft.prerelease, parsedRight.prerelease);
+}
+function resolveCliUpdateCheckCachePath(packageName, options = {}) {
+    const workspace = options.workspace?.trim();
+    const configDir = options.configDir?.trim() || ".wingman";
+    if (workspace) {
+        const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+        if ((0, external_node_fs_namespaceObject.existsSync)(configRoot)) return (0, external_node_path_namespaceObject.join)(configRoot, "cache", "update-check.json");
+    }
+    return (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-update-check", sanitizePackageName(packageName), "update-check.json");
+}
+async function checkForCliUpdate(options = {}) {
+    const packageMetadata = options.packageMetadata ?? await loadCliPackageMetadata(options.packageJsonUrl);
+    if (!packageMetadata) return null;
+    const now = options.now ?? new Date();
+    const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    const cachePath = resolveCliUpdateCheckCachePath(packageMetadata.name, options);
+    const cached = await readCachedUpdateCheck(cachePath);
+    if (cached && isCacheUsable(cached, packageMetadata, now, cacheTtlMs)) return toUpdateNotice(packageMetadata.name, packageMetadata.version, cached.latestVersion);
+    const latestVersion = await fetchLatestPackageVersion(packageMetadata.name, options.fetchImpl ?? globalThis.fetch, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.logger);
+    if (latestVersion) {
+        const nextCacheEntry = {
+            packageName: packageMetadata.name,
+            currentVersion: packageMetadata.version,
+            latestVersion,
+            checkedAt: now.toISOString()
+        };
+        try {
+            await writeCachedUpdateCheck(cachePath, nextCacheEntry);
+        } catch (error) {
+            options.logger?.debug?.("Failed to persist CLI update-check cache", error instanceof Error ? error.message : String(error));
+        }
+        return toUpdateNotice(packageMetadata.name, packageMetadata.version, latestVersion);
+    }
+    if (cached && cached.packageName === packageMetadata.name && cached.currentVersion === packageMetadata.version) return toUpdateNotice(packageMetadata.name, packageMetadata.version, cached.latestVersion);
+    return null;
+}
+function parseVersion(version) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/.exec(version.trim());
+    if (!match) return null;
+    return {
+        core: [
+            Number.parseInt(match[1], 10),
+            Number.parseInt(match[2], 10),
+            Number.parseInt(match[3], 10)
+        ],
+        prerelease: match[4] ? match[4].split(".") : []
+    };
+}
+function comparePrerelease(left, right) {
+    if (0 === left.length && 0 === right.length) return 0;
+    if (0 === left.length) return 1;
+    if (0 === right.length) return -1;
+    const maxLength = Math.max(left.length, right.length);
+    for(let index = 0; index < maxLength; index++){
+        const leftIdentifier = left[index];
+        const rightIdentifier = right[index];
+        if (void 0 === leftIdentifier) return -1;
+        if (void 0 === rightIdentifier) return 1;
+        if (leftIdentifier === rightIdentifier) continue;
+        const leftIsNumeric = isNumericIdentifier(leftIdentifier);
+        const rightIsNumeric = isNumericIdentifier(rightIdentifier);
+        if (leftIsNumeric && rightIsNumeric) return Number.parseInt(leftIdentifier, 10) - Number.parseInt(rightIdentifier, 10);
+        if (leftIsNumeric) return -1;
+        if (rightIsNumeric) return 1;
+        return leftIdentifier < rightIdentifier ? -1 : 1;
+    }
+    return 0;
+}
+function isNumericIdentifier(value) {
+    return /^\d+$/.test(value);
+}
+function sanitizePackageName(packageName) {
+    return packageName.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function toUpdateNotice(packageName, currentVersion, latestVersion) {
+    if (compareCliVersions(latestVersion, currentVersion) <= 0) return null;
+    return {
+        packageName,
+        currentVersion,
+        latestVersion,
+        command: `npm install -g ${packageName}@latest`
+    };
+}
+function isCacheUsable(cacheEntry, packageMetadata, now, cacheTtlMs) {
+    if (cacheEntry.packageName !== packageMetadata.name) return false;
+    if (cacheEntry.currentVersion !== packageMetadata.version) return false;
+    const checkedAtMs = Date.parse(cacheEntry.checkedAt);
+    if (!Number.isFinite(checkedAtMs)) return false;
+    return now.getTime() - checkedAtMs <= cacheTtlMs;
+}
+async function readCachedUpdateCheck(cachePath) {
+    try {
+        const raw = await (0, promises_namespaceObject.readFile)(cachePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if ("string" != typeof parsed.packageName || "string" != typeof parsed.currentVersion || "string" != typeof parsed.latestVersion || "string" != typeof parsed.checkedAt) return null;
+        return {
+            packageName: parsed.packageName,
+            currentVersion: parsed.currentVersion,
+            latestVersion: parsed.latestVersion,
+            checkedAt: parsed.checkedAt
+        };
+    } catch  {
+        return null;
+    }
+}
+async function writeCachedUpdateCheck(cachePath, cacheEntry) {
+    await (0, promises_namespaceObject.mkdir)((0, external_node_path_namespaceObject.dirname)(cachePath), {
+        recursive: true
+    });
+    await (0, promises_namespaceObject.writeFile)(cachePath, `${JSON.stringify(cacheEntry, null, 2)}\n`, "utf-8");
+}
+async function fetchLatestPackageVersion(packageName, fetchImpl, timeoutMs, logger) {
+    if ("function" != typeof fetchImpl) return null;
+    const controller = new AbortController();
+    const timeout = setTimeout(()=>controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, {
+            headers: {
+                accept: "application/json"
+            },
+            signal: controller.signal
+        });
+        if (!response.ok) return null;
+        const payload = await response.json();
+        if ("string" != typeof payload.version) return null;
+        const latestVersion = payload.version.trim();
+        return latestVersion || null;
+    } catch (error) {
+        logger?.debug?.("CLI update check skipped", error instanceof Error ? error.message : String(error));
+        return null;
+    } finally{
+        clearTimeout(timeout);
+    }
+}
+exports.checkForCliUpdate = __webpack_exports__.checkForCliUpdate;
+exports.compareCliVersions = __webpack_exports__.compareCliVersions;
+exports.loadCliPackageMetadata = __webpack_exports__.loadCliPackageMetadata;
+exports.resolveCliUpdateCheckCachePath = __webpack_exports__.resolveCliUpdateCheckCachePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "checkForCliUpdate",
+    "compareCliVersions",
+    "loadCliPackageMetadata",
+    "resolveCliUpdateCheckCachePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/services/updateCheck.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "@/logger.js";
+export interface CliPackageMetadata {
+    name: string;
+    version: string;
+}
+export interface CliUpdateNotice {
+    packageName: string;
+    currentVersion: string;
+    latestVersion: string;
+    command: string;
+}
+export interface CliUpdateCheckOptions {
+    workspace?: string;
+    configDir?: string;
+    fetchImpl?: typeof fetch;
+    now?: Date;
+    timeoutMs?: number;
+    cacheTtlMs?: number;
+    logger?: Pick<Logger, "debug">;
+    packageMetadata?: CliPackageMetadata;
+    packageJsonUrl?: URL;
+}
+export declare function loadCliPackageMetadata(packageJsonUrl?: URL): Promise<CliPackageMetadata | null>;
+export declare function compareCliVersions(left: string, right: string): number;
+export declare function resolveCliUpdateCheckCachePath(packageName: string, options?: Pick<CliUpdateCheckOptions, "workspace" | "configDir">): string;
+export declare function checkForCliUpdate(options?: CliUpdateCheckOptions): Promise<CliUpdateNotice | null>;