@remotedraw/cli 0.1.1 → 0.1.3

package/dist/update.d.ts

@@ -0,0 +1,53 @@
+import { type CloudRuntime } from "./cloud.js";
+export declare const CLI_PACKAGE_NAME = "@remotedraw/cli";
+export type UpdateRuntime = CloudRuntime & {
+    /**
+     * Runs an installer. Absent in unit tests and in any runtime that must not
+     * spawn processes, which makes `remotedraw update` report the command instead
+     * of running it.
+     */
+    spawnCommand?: (command: string, args: string[]) => Promise<{
+        exitCode: number;
+    }>;
+};
+export type InstallMethod = {
+    /** Package manager the binary appears to have been installed with. */
+    manager: "npm" | "pnpm" | "yarn" | "bun";
+    /** True when the binary was resolved by npx/bunx, which never needs updating. */
+    ephemeral: boolean;
+    command: string;
+    args: string[];
+};
+export type UpdateCheck = {
+    current: string;
+    latest: string;
+    updateAvailable: boolean;
+};
+export declare function parseVersion(value: string): {
+    numbers: number[];
+    prerelease: string;
+};
+export declare function compareVersions(a: string, b: string): 1 | 0 | -1;
+/**
+ * Derives the update command from where the running binary lives. Guessing
+ * wrong only prints the wrong suggestion, so the fallback is plain npm.
+ */
+export declare function detectInstallMethod(binPath: string): InstallMethod;
+export declare function installMethodDisplay(method: InstallMethod): string;
+export declare function updateCachePath(runtime: UpdateRuntime): string;
+export declare function latestPublishedVersion(runtime: UpdateRuntime, timeoutMs?: number): Promise<string | undefined>;
+/** True when the environment asked us not to make an update request at all. */
+export declare function updateChecksDisabled(env: Record<string, string | undefined>): boolean;
+export declare function checkForUpdate(runtime: UpdateRuntime, currentVersion: string, options?: {
+    force?: boolean;
+    now?: number;
+}): Promise<UpdateCheck | undefined>;
+export declare function updateNotice(check: UpdateCheck, method: InstallMethod): string;
+export declare function runInstall(runtime: UpdateRuntime, method: InstallMethod): Promise<{
+    ran: false;
+    exitCode?: never;
+} | {
+    ran: true;
+    exitCode: number;
+}>;
+//# sourceMappingURL=update.d.ts.map

package/dist/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../src/update.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAOlD,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IACzC;;;;OAIG;IACH,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,KACX,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,sEAAsE;IACtE,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IACzC,iFAAiF;IACjF,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAiBF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM;;;EAczC;AA2BD,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,cASnD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAoClE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,UAEzD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,UAErD;AAgDD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,aAAa,EACtB,SAAS,SAAmB,+BAoC7B;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,WAO3E;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9C,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CA2BlC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,UAOrE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa;;;;;;GAM7E"}

package/dist/update.js

@@ -0,0 +1,235 @@
+import path from "node:path";
+import { globalConfigPath } from "./cloud.js";
+export const CLI_PACKAGE_NAME = "@remotedraw/cli";
+const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** The passive notice must never delay a command; an explicit check may wait. */
+const CHECK_TIMEOUT_MS = 2_000;
+const FORCED_CHECK_TIMEOUT_MS = 10_000;
+/**
+ * npm registry semantics: a globally installed package is a pinned snapshot,
+ * so the CLI has to ask the registry itself to know it is stale.
+ */
+function registryUrl(env) {
+    const configured = env.REMOTEDRAW_CLI_REGISTRY?.trim() || env.npm_config_registry?.trim();
+    return (configured || DEFAULT_REGISTRY_URL).replace(/\/+$/, "");
+}
+export function parseVersion(value) {
+    const trimmed = value.trim().replace(/^v/, "");
+    const separator = trimmed.indexOf("-");
+    const core = separator === -1 ? trimmed : trimmed.slice(0, separator);
+    const prerelease = separator === -1 ? "" : trimmed.slice(separator + 1);
+    const numbers = core
+        .split(".")
+        .slice(0, 3)
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    while (numbers.length < 3)
+        numbers.push(0);
+    return { numbers, prerelease };
+}
+function comparePrerelease(a, b) {
+    if (a === b)
+        return 0;
+    // A release always outranks any prerelease of the same core version.
+    if (!a)
+        return 1;
+    if (!b)
+        return -1;
+    const left = a.split(".");
+    const right = b.split(".");
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart == null)
+            return -1;
+        if (rightPart == null)
+            return 1;
+        const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : undefined;
+        const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : undefined;
+        if (leftNumber != null && rightNumber != null) {
+            if (leftNumber !== rightNumber)
+                return leftNumber < rightNumber ? -1 : 1;
+            continue;
+        }
+        if (leftNumber != null)
+            return -1;
+        if (rightNumber != null)
+            return 1;
+        if (leftPart !== rightPart)
+            return leftPart < rightPart ? -1 : 1;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    for (let index = 0; index < 3; index += 1) {
+        const leftNumber = left.numbers[index] ?? 0;
+        const rightNumber = right.numbers[index] ?? 0;
+        if (leftNumber !== rightNumber)
+            return leftNumber < rightNumber ? -1 : 1;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+/**
+ * Derives the update command from where the running binary lives. Guessing
+ * wrong only prints the wrong suggestion, so the fallback is plain npm.
+ */
+export function detectInstallMethod(binPath) {
+    const normalized = binPath.replace(/\\/g, "/");
+    const update = `${CLI_PACKAGE_NAME}@latest`;
+    if (/\/(_npx|\.npm\/_npx|\.bun\/install\/cache)\//.test(normalized)) {
+        return { manager: "npm", ephemeral: true, command: "npx", args: [update] };
+    }
+    if (/\/\.bun\//.test(normalized)) {
+        return {
+            manager: "bun",
+            ephemeral: false,
+            command: "bun",
+            args: ["add", "--global", update],
+        };
+    }
+    if (/\/(\.pnpm|pnpm)\//.test(normalized)) {
+        return {
+            manager: "pnpm",
+            ephemeral: false,
+            command: "pnpm",
+            args: ["add", "--global", update],
+        };
+    }
+    if (/\/(\.yarn|Yarn)\//.test(normalized)) {
+        return {
+            manager: "yarn",
+            ephemeral: false,
+            command: "yarn",
+            args: ["global", "add", update],
+        };
+    }
+    return {
+        manager: "npm",
+        ephemeral: false,
+        command: "npm",
+        args: ["install", "--global", update],
+    };
+}
+export function installMethodDisplay(method) {
+    return [method.command, ...method.args].join(" ");
+}
+export function updateCachePath(runtime) {
+    return path.join(path.dirname(globalConfigPath(runtime)), "update-check.json");
+}
+async function readUpdateCache(runtime) {
+    const cachePath = updateCachePath(runtime);
+    if (!(await runtime.exists(cachePath)))
+        return undefined;
+    try {
+        const parsed = JSON.parse(await runtime.readFile(cachePath));
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            typeof parsed.latest !== "string" ||
+            typeof parsed.checkedAt !== "number") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        // A corrupt cache is never fatal; the next check rewrites it.
+        return undefined;
+    }
+}
+async function writeUpdateCache(runtime, cache) {
+    try {
+        const cachePath = updateCachePath(runtime);
+        await runtime.mkdir(path.dirname(cachePath));
+        await runtime.writeFile(cachePath, `${JSON.stringify(cache)}\n`);
+    }
+    catch {
+        // A read-only config dir must not break the command the user actually ran.
+    }
+}
+async function registryJson(runtime, url, accept, timeoutMs) {
+    const response = await runtime.fetch?.(url, {
+        headers: { Accept: accept },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response?.ok)
+        return undefined;
+    return (await response.json());
+}
+export async function latestPublishedVersion(runtime, timeoutMs = CHECK_TIMEOUT_MS) {
+    if (!runtime.fetch)
+        return undefined;
+    const base = `${registryUrl(runtime.env)}/${CLI_PACKAGE_NAME}`;
+    try {
+        // `/latest` is one version manifest rather than the whole packument, so it
+        // stays small as releases accumulate. It rejects npm's abbreviated-packument
+        // Accept header with a 406, hence plain JSON here.
+        const manifest = await registryJson(runtime, `${base}/latest`, "application/json", timeoutMs);
+        if (typeof manifest?.version === "string")
+            return manifest.version;
+        // Registries and mirrors that do not serve `/latest` still serve dist-tags
+        // on the abbreviated packument.
+        const packument = await registryJson(runtime, base, "application/vnd.npm.install-v1+json", timeoutMs);
+        const distTags = packument?.["dist-tags"];
+        if (typeof distTags === "object" &&
+            distTags !== null &&
+            typeof distTags.latest === "string") {
+            return distTags.latest;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when the environment asked us not to make an update request at all. */
+export function updateChecksDisabled(env) {
+    return Boolean(env.REMOTEDRAW_CLI_OFFLINE === "1" ||
+        env.REMOTEDRAW_CLI_NO_UPDATE_CHECK === "1" ||
+        env.NO_UPDATE_NOTIFIER ||
+        env.CI);
+}
+export async function checkForUpdate(runtime, currentVersion, options = {}) {
+    if (currentVersion === "unknown")
+        return undefined;
+    if (!options.force && updateChecksDisabled(runtime.env))
+        return undefined;
+    const now = options.now ?? Date.now();
+    if (!options.force) {
+        const cached = await readUpdateCache(runtime);
+        if (cached && now - cached.checkedAt < CHECK_INTERVAL_MS) {
+            return {
+                current: currentVersion,
+                latest: cached.latest,
+                updateAvailable: compareVersions(currentVersion, cached.latest) < 0,
+            };
+        }
+    }
+    const latest = await latestPublishedVersion(runtime, options.force ? FORCED_CHECK_TIMEOUT_MS : CHECK_TIMEOUT_MS);
+    if (!latest)
+        return undefined;
+    await writeUpdateCache(runtime, { checkedAt: now, latest });
+    return {
+        current: currentVersion,
+        latest,
+        updateAvailable: compareVersions(currentVersion, latest) < 0,
+    };
+}
+export function updateNotice(check, method) {
+    return [
+        `Update available: ${CLI_PACKAGE_NAME} ${check.current} -> ${check.latest}`,
+        method.ephemeral
+            ? `Run remotedraw with ${CLI_PACKAGE_NAME}@latest to pick it up.`
+            : `Run remotedraw update (or ${installMethodDisplay(method)}).`,
+    ].join("\n");
+}
+export async function runInstall(runtime, method) {
+    if (!runtime.spawnCommand) {
+        return { ran: false };
+    }
+    const result = await runtime.spawnCommand(method.command, method.args);
+    return { ran: true, exitCode: result.exitCode };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotedraw/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Command-line tools for creating and inspecting RemoteDraw integrations.",
   "type": "module",
   "bin": {
@@ -13,15 +13,10 @@
   "engines": {
     "node": ">=20"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/AxioSOzo/RemoteDraw.git",
-    "directory": "packages/cli"
-  },
   "bugs": {
-    "url": "https://github.com/AxioSOzo/RemoteDraw/issues"
+    "email": "support@remotedraw.com"
   },
-  "homepage": "https://github.com/AxioSOzo/RemoteDraw#readme",
+  "homepage": "https://docs.remotedraw.com",
   "keywords": [
     "remotedraw",
     "drawing",