ninepm 0.49.0 → 0.51.0

package/dist/index.d.ts

@@ -114,7 +114,7 @@ export interface CreatedServiceToken {
     clientSecret: string;
 }
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-export declare const CLI_VERSION = "0.49.0";
+export declare const CLI_VERSION = "0.51.0";
 type CredentialBackend = "macos-keychain" | "windows-dpapi" | "linux-secret-service" | "file-plaintext" | "none";
 export interface StoredCredentialEntry {
     token: string;
@@ -284,6 +284,13 @@ export declare function checkCliVersion(options: {
     fetchFn?: FetchLike;
     timeoutMs?: number;
 }): Promise<CliVersionCheck>;
+export interface UpdateNudgeOptions {
+    fetchFn?: FetchLike;
+    now?: () => Date;
+    cachePath?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function deployUpdateNudge(options?: UpdateNudgeOptions): Promise<string | null>;
 export interface ListSitesResult {
     projects: Project[];
 }

package/dist/index.js

@@ -14,7 +14,7 @@ import { MAX_DEPLOY_DESCRIPTION_LENGTH, normalizeDeployDescription } from "./dep
 import { MAX_STATIC_ASSET_FILE_BYTES, MAX_WORKER_ENTRY_COMPRESSED_BYTES, MAX_WORKER_SCRIPT_COMPRESSED_BYTES, WORKER_ENTRY_COMPRESSED_WARN_BYTES, assetFileTooLargeMessage, formatMebibytes, formatMegabytes, oversizedAssets, workerBundleNearLimitMessage, workerBundleTooLargeMessage, workerEntryNearLimitMessage, workerEntryTooLargeMessage, } from "./deploy-limits.js";
 import { buildFileManifest, readManifestFile } from "./manifest.js";
 import { API_KEY_HELP, API_URL_HELP, CLI_CLIENT_ID, DEFAULT_API_URL, reportCliError } from "./cli-config.js";
-export const CLI_VERSION = "0.49.0";
+export const CLI_VERSION = "0.51.0";
 const PUBLIC_DASHBOARD_URL = "https://9pm.ai/dashboard";
 const TOKEN_SERVICE = "9pm";
 const TOKEN_ACCOUNT = "default";
@@ -1021,6 +1021,72 @@ export async function checkCliVersion(options) {
     const latest = await fetchLatestCliVersion(options);
     return { current: CLI_VERSION, latest, comparison: compareCliVersions(CLI_VERSION, latest.version) };
 }
+// Passive update nudge after a successful deploy (#996). Deliberately quiet:
+// at most one registry probe per interval (answer cached in the credential
+// config dir), a short timeout so a slow registry never holds up a deploy that
+// already finished, and every failure — network, malformed cache, unwritable
+// config dir — resolves to null, so the nudge can only ever add a line.
+const UPDATE_NUDGE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_NUDGE_TIMEOUT_MS = 1500;
+const UPDATE_NUDGE_CACHE_FILE = "update-check.json";
+const NO_UPDATE_CHECK_ENV = "NINEPM_NO_UPDATE_CHECK";
+export async function deployUpdateNudge(options = {}) {
+    const env = options.env ?? process.env;
+    if (isTruthyEnv(env[NO_UPDATE_CHECK_ENV])) {
+        return null;
+    }
+    const now = options.now?.() ?? new Date();
+    const cachePath = options.cachePath ?? path.join(credentialConfigDir(), UPDATE_NUDGE_CACHE_FILE);
+    const cache = readUpdateCheckCache(cachePath);
+    // A checkedAt in the future (clock rollback) reads as fresh on purpose —
+    // expiring it would probe the registry on every deploy until the clock
+    // catches back up.
+    const fresh = cache.checkedAtMs !== null && now.getTime() - cache.checkedAtMs < UPDATE_NUDGE_INTERVAL_MS;
+    let latest = cache.latest;
+    if (!fresh) {
+        try {
+            const fetched = await fetchLatestCliVersion({
+                apiUrl: "", // unused: the updater sources the public npm registry (see fetchLatestCliVersion)
+                timeoutMs: UPDATE_NUDGE_TIMEOUT_MS,
+                ...(options.fetchFn ? { fetchFn: options.fetchFn } : {}),
+            });
+            latest = fetched.version;
+        }
+        catch {
+            // Keep the last-known answer (if any) for the comparison below. The
+            // attempt is still stamped: an unreachable registry must not re-add its
+            // timeout to every deploy for the rest of the interval.
+        }
+        try {
+            mkdirSync(path.dirname(cachePath), { recursive: true });
+            writeFileSync(cachePath, JSON.stringify({ checkedAt: now.toISOString(), ...(latest ? { latest } : {}) }));
+        }
+        catch {
+            // The cache only spaces out probes; a read-only config dir just means the
+            // next deploy probes again.
+        }
+    }
+    if (!latest || compareCliVersions(CLI_VERSION, latest) !== "behind") {
+        return null;
+    }
+    return `Update available: 9pm CLI ${CLI_VERSION} -> ${latest}. Run: npm i -g ninepm@latest`;
+}
+// Best-effort read of the update-check cache; the caller judges freshness.
+// checkedAtMs is null when the file is missing or malformed (so the next probe
+// runs now), and latest is null when the last attempt failed to get an answer
+// — a failed attempt is cached too, so the outage's timeout is paid at most
+// once per interval rather than on every deploy.
+function readUpdateCheckCache(cachePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        const checkedAtMs = typeof parsed.checkedAt === "string" ? Date.parse(parsed.checkedAt) : Number.NaN;
+        const latest = typeof parsed.latest === "string" && parsed.latest.trim() ? parsed.latest.trim() : null;
+        return { checkedAtMs: Number.isFinite(checkedAtMs) ? checkedAtMs : null, latest };
+    }
+    catch {
+        return { checkedAtMs: null, latest: null };
+    }
+}
 export async function listSites(options) {
     const payload = await apiRequest(options, "/v1/sites", { method: "GET" });
     return { projects: payload.projects };
@@ -3686,6 +3752,14 @@ async function main() {
                 console.log(`Status: ${result.deployment.status}. Run 9pm apps to check when it becomes active.`);
             }
             console.log(`Manage: ${PUBLIC_DASHBOARD_URL}`);
+            // Gated the same way as the reachability probe above: a programmatic
+            // caller injecting fetchFn opted out of the CLI's own network side trips.
+            if (!command.options.fetchFn) {
+                const nudge = await deployUpdateNudge();
+                if (nudge) {
+                    console.log(nudge);
+                }
+            }
             return;
         }
         if (command.kind === "login") {
@@ -4161,7 +4235,11 @@ Container deploys:
   --cpus <n> and --memory <size> (512m, 2048, 4g); the platform picks a placement that fits.
   All of these may require platform enablement.
   A redeploy KEEPS the app's existing disk automatically: omit --volume and the current disk is
-  carried forward. To remove the disk on purpose pass --no-volume (and --allow-data-wipe, since it
+  carried forward. A LARGER --volume than the current disk grows it in place (same disk, data
+  preserved). Sizes never shrink: a smaller --volume is refused — to recreate the disk smaller,
+  drop it first (--no-volume --allow-data-wipe, which destroys its data), then deploy again
+  with the smaller --volume (fresh empty disk).
+  To remove the disk on purpose pass --no-volume (and --allow-data-wipe, since it
   destroys the data). If a disk was previously detached by an old CLI, redeploy with --volume <same
   gb> --region <same region> to reattach the existing disk (it is reused, not recreated empty).
   --allow-data-wipe acknowledges that dropping a disk, or switching to a placement that can't keep

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ninepm",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "description": "CLI for deploying built apps to 9pm.ai.",
   "homepage": "https://9pm.ai",
   "keywords": [