@nuanu-ai/agentbrowse 0.2.29 → 0.2.31

package/dist/update-check.js

@@ -0,0 +1,182 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSolverDir } from './solver/config.js';
+const PACKAGE_NAME = '@nuanu-ai/agentbrowse';
+const PACKAGE_JSON_URL = new URL('../package.json', import.meta.url);
+const REGISTRY_METADATA_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}`;
+const DEFAULT_UPDATE_CHECK_TIMEOUT_MS = 1500;
+const DEFAULT_UPDATE_TTL_MS = 12 * 60 * 60 * 1000;
+export function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return left.localeCompare(right, undefined, {
+            numeric: true,
+            sensitivity: 'base',
+        });
+    }
+    for (let i = 0; i < 3; i += 1) {
+        const diff = parsedLeft.core[i] - parsedRight.core[i];
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    if (!parsedLeft.prerelease && !parsedRight.prerelease) {
+        return 0;
+    }
+    if (!parsedLeft.prerelease) {
+        return 1;
+    }
+    if (!parsedRight.prerelease) {
+        return -1;
+    }
+    const length = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+    for (let i = 0; i < length; i += 1) {
+        const leftPart = parsedLeft.prerelease[i];
+        const rightPart = parsedRight.prerelease[i];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        if (typeof leftPart === 'number' && typeof rightPart === 'number') {
+            const diff = leftPart - rightPart;
+            if (diff !== 0) {
+                return diff;
+            }
+            continue;
+        }
+        if (typeof leftPart === 'number') {
+            return -1;
+        }
+        if (typeof rightPart === 'number') {
+            return 1;
+        }
+        const diff = leftPart.localeCompare(rightPart);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+export async function checkForLaunchUpdate(options = {}) {
+    const currentVersion = readCurrentPackageVersion();
+    const now = options.now ?? new Date();
+    const ttlMs = options.ttlMs ?? DEFAULT_UPDATE_TTL_MS;
+    const cachedState = readUpdateState();
+    const cachedNotice = buildLaunchUpdateNotice(currentVersion, cachedState?.latestVersion);
+    if (cachedState && !isCacheStale(cachedState.lastCheckedAt, now, ttlMs)) {
+        return cachedNotice;
+    }
+    const latestVersion = await fetchLatestVersion({
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs ?? DEFAULT_UPDATE_CHECK_TIMEOUT_MS,
+    }).catch(() => null);
+    if (!latestVersion) {
+        return cachedNotice;
+    }
+    writeUpdateState({
+        packageName: PACKAGE_NAME,
+        latestVersion,
+        lastCheckedAt: now.toISOString(),
+    });
+    return buildLaunchUpdateNotice(currentVersion, latestVersion);
+}
+function parseVersion(version) {
+    const match = version
+        .trim()
+        .match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+.*)?$/);
+    if (!match) {
+        return null;
+    }
+    const prerelease = match[4]
+        ? match[4].split('.').map((part) => (/^\d+$/.test(part) ? Number(part) : part))
+        : null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease,
+    };
+}
+function buildLaunchUpdateNotice(currentVersion, latestVersion) {
+    if (!latestVersion || compareVersions(latestVersion, currentVersion) <= 0) {
+        return null;
+    }
+    return {
+        currentVersion,
+        latestVersion,
+        message: `A newer agentbrowse version is available: ${latestVersion} (current: ${currentVersion}). Update with: npm i -g ${PACKAGE_NAME}@latest`,
+    };
+}
+function readCurrentPackageVersion() {
+    const raw = JSON.parse(readFileSync(PACKAGE_JSON_URL, 'utf-8'));
+    if (!raw.version || typeof raw.version !== 'string') {
+        throw new Error('Package version is missing from package.json.');
+    }
+    return raw.version;
+}
+function readUpdateState() {
+    const updateStatePath = getUpdateStatePath();
+    if (!existsSync(updateStatePath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(updateStatePath, 'utf-8'));
+        if (raw.packageName !== PACKAGE_NAME ||
+            typeof raw.latestVersion !== 'string' ||
+            typeof raw.lastCheckedAt !== 'string') {
+            return null;
+        }
+        return {
+            packageName: raw.packageName,
+            latestVersion: raw.latestVersion,
+            lastCheckedAt: raw.lastCheckedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeUpdateState(state) {
+    const solverDir = getSolverDir();
+    mkdirSync(solverDir, { recursive: true });
+    writeFileSync(getUpdateStatePath(), JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+function isCacheStale(lastCheckedAt, now, ttlMs) {
+    const lastCheckedAtMs = new Date(lastCheckedAt).getTime();
+    if (!Number.isFinite(lastCheckedAtMs)) {
+        return true;
+    }
+    return now.getTime() - lastCheckedAtMs >= ttlMs;
+}
+async function fetchLatestVersion(options) {
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== 'function') {
+        throw new Error('Global fetch is not available.');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+        const response = await fetchImpl(REGISTRY_METADATA_URL, {
+            headers: {
+                Accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Registry responded with ${response.status}.`);
+        }
+        const metadata = (await response.json());
+        const latestVersion = metadata['dist-tags']?.latest;
+        if (!latestVersion || typeof latestVersion !== 'string') {
+            throw new Error('Registry metadata does not include dist-tags.latest.');
+        }
+        return latestVersion;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function getUpdateStatePath() {
+    return join(getSolverDir(), 'update-state.json');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuanu-ai/agentbrowse",
-  "version": "0.2.29",
+  "version": "0.2.31",
   "type": "module",
   "description": "Browser automation CLI for AI agents: control a CDP browser, observe UI surfaces, act on refs, extract data, capture screenshots, complete protected fills, and solve captchas",
   "keywords": [