ninepm 0.49.0 → 0.52.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.52.0";
 type CredentialBackend = "macos-keychain" | "windows-dpapi" | "linux-secret-service" | "file-plaintext" | "none";
 export interface StoredCredentialEntry {
     token: string;
@@ -284,6 +284,24 @@ 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 SkillFreshness {
+    status: "up_to_date" | "stale" | "not_installed" | "unknown";
+    installedStamp?: string;
+    publishedStamp?: string;
+    detail?: string;
+}
+export declare function checkSkillFreshness(options?: {
+    fetchFn?: FetchLike;
+    skillPath?: string;
+    timeoutMs?: number;
+}): Promise<SkillFreshness>;
 export interface ListSitesResult {
     projects: Project[];
 }
@@ -353,6 +371,8 @@ export interface DeviceAuthProgressReporter {
     stop(): void;
 }
 export declare function createDeviceAuthProgressReporter(stream?: NodeJS.WriteStream): DeviceAuthProgressReporter;
+export declare function noteCliOutdatedAdvisory(response: Response, log?: (line: string) => void): void;
+export declare function resetCliOutdatedAdvisoryForTests(): void;
 type CliCommand = {
     kind: "deploy";
     options: DeployOptions;

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.52.0";
 const PUBLIC_DASHBOARD_URL = "https://9pm.ai/dashboard";
 const TOKEN_SERVICE = "9pm";
 const TOKEN_ACCOUNT = "default";
@@ -499,6 +499,7 @@ async function runDeploy(initialOptions, slugHolder) {
             method: upload.method,
             headers: {
                 authorization: `Bearer ${options.token}`,
+                ...cliVersionHeader(),
                 ...upload.headers,
             },
             body: arrayBufferFromBytes(body),
@@ -856,8 +857,9 @@ async function doctor(options) {
     catch (error) {
         versionError = error instanceof Error ? error.message : String(error);
     }
+    const skill = await checkSkillFreshness();
     if (options.json) {
-        console.log(JSON.stringify({ apiUrl: normalizeApiUrl(options.apiUrl), credentials, account, accountError, version: versionCheck, versionError }, null, 2));
+        console.log(JSON.stringify({ apiUrl: normalizeApiUrl(options.apiUrl), credentials, account, accountError, version: versionCheck, versionError, skill }, null, 2));
         return;
     }
     console.log("9pm.ai doctor");
@@ -898,6 +900,18 @@ async function doctor(options) {
     else if (versionError) {
         console.log(`CLI: ${CLI_VERSION} (latest unavailable: ${versionError})`);
     }
+    if (skill.status === "up_to_date") {
+        console.log(`Skill: up to date (stamp ${skill.installedStamp})`);
+    }
+    else if (skill.status === "stale") {
+        console.log(`Skill: stale (installed ${skill.installedStamp ?? "no stamp"}, published ${skill.publishedStamp}). Refresh: ${SKILL_REFRESH_COMMAND}`);
+    }
+    else if (skill.status === "not_installed") {
+        console.log("Skill: not installed (expected at ~/.agents/skills/9pm/SKILL.md)");
+    }
+    else {
+        console.log(`Skill: installed; freshness unknown (${skill.detail ?? "no detail"})`);
+    }
 }
 export async function getSiteAccess(options) {
     return apiRequest(options, `/v1/sites/${encodeURIComponent(options.site)}/access`, {
@@ -1021,6 +1035,122 @@ 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`;
+}
+// Skill-freshness half of `9pm doctor` (#996): compare the installed skill's
+// stamp line against the public source copy — the same reference SKILL.md's
+// own "Keeping this skill fresh" section names, and the source the install
+// command actually pulls from (the platform-hosted copy tracks releases and
+// can lag it). Never throws: doctor is diagnostics, not a gate.
+const SKILL_INSTALL_PATH_SEGMENTS = [".agents", "skills", "9pm", "SKILL.md"];
+const SKILL_SOURCE_URL = "https://raw.githubusercontent.com/tmrw-realityos/9pm-skill/main/skills/9pm/SKILL.md";
+const SKILL_STAMP_PATTERN = /^Skill guide stamp:\s*(\S+)/m;
+const SKILL_REFRESH_COMMAND = "npx skills add tmrw-realityos/9pm-skill --skill 9pm -g";
+export async function checkSkillFreshness(options = {}) {
+    const skillPath = options.skillPath ?? path.join(os.homedir(), ...SKILL_INSTALL_PATH_SEGMENTS);
+    let installed;
+    try {
+        installed = readFileSync(skillPath, "utf8");
+    }
+    catch {
+        return { status: "not_installed" };
+    }
+    const installedStamp = SKILL_STAMP_PATTERN.exec(installed)?.[1] ?? null;
+    const fetchFn = options.fetchFn ?? fetch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 3000);
+    let publishedStamp = null;
+    try {
+        const response = await fetchFn(SKILL_SOURCE_URL, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`skill source returned ${response.status}`);
+        }
+        publishedStamp = SKILL_STAMP_PATTERN.exec(await response.text())?.[1] ?? null;
+    }
+    catch (error) {
+        return {
+            status: "unknown",
+            ...(installedStamp ? { installedStamp } : {}),
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!publishedStamp) {
+        return { status: "unknown", ...(installedStamp ? { installedStamp } : {}), detail: "published copy has no stamp line" };
+    }
+    // An installed copy with no stamp predates the stamp convention, which is
+    // itself proof it is behind.
+    if (!installedStamp || installedStamp !== publishedStamp) {
+        return { status: "stale", ...(installedStamp ? { installedStamp } : {}), publishedStamp };
+    }
+    return { status: "up_to_date", installedStamp, publishedStamp };
+}
+// 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 };
@@ -1048,7 +1178,7 @@ async function deviceAuthFlow(options) {
     // made here; an unpredictable store failure is caught after the poll instead.
     const startResponse = await fetchFn(`${apiUrl}/v1/oauth/device/start`, {
         method: "POST",
-        headers: { "content-type": "application/json" },
+        headers: { "content-type": "application/json", ...cliVersionHeader() },
         body: JSON.stringify({ machineName: options.machineName ?? os.hostname(), purpose: options.purpose }),
     });
     // The control plane refuses a signup it knows can never be approved (#507) with
@@ -1114,7 +1244,7 @@ async function deviceAuthFlow(options) {
             await sleep(intervalMs);
             const pollResponse = await fetchFn(`${apiUrl}/v1/oauth/device/poll`, {
                 method: "POST",
-                headers: { "content-type": "application/json" },
+                headers: { "content-type": "application/json", ...cliVersionHeader() },
                 body: JSON.stringify({ code: deviceCode }),
             });
             if (pollResponse.status === 400) {
@@ -1283,6 +1413,7 @@ export async function putManagedFile(options) {
         headers: {
             authorization: `Bearer ${options.token}`,
             "content-type": "application/octet-stream",
+            ...cliVersionHeader(),
         },
         body: bytes,
     });
@@ -1293,7 +1424,7 @@ export async function getManagedFile(options) {
     const apiUrl = normalizeApiUrl(options.apiUrl);
     const response = await fetchFn(`${apiUrl}${filesRoute(options)}/${encodeURIComponent(options.fileId)}`, {
         method: "GET",
-        headers: { authorization: `Bearer ${options.token}` },
+        headers: { authorization: `Bearer ${options.token}`, ...cliVersionHeader() },
     });
     await expectOk(response, "download file");
     const bytes = new Uint8Array(await response.arrayBuffer());
@@ -1366,7 +1497,7 @@ async function finalizeDeployment(fetchFn, apiUrl, token, deploymentId) {
 async function getDeployment(fetchFn, apiUrl, token, deploymentId) {
     const response = await fetchFn(`${apiUrl}/v1/deployments/${encodeURIComponent(deploymentId)}`, {
         method: "GET",
-        headers: { authorization: `Bearer ${token}` },
+        headers: { authorization: `Bearer ${token}`, ...cliVersionHeader() },
     });
     const payload = await expectJson(response, "get deployment");
     return payload.deployment;
@@ -1803,20 +1934,56 @@ function jsonHeaders(token) {
     return {
         authorization: `Bearer ${token}`,
         "content-type": "application/json",
-        "x-9pm-cli-version": CLI_VERSION,
+        ...cliVersionHeader(),
     };
 }
+// Every control-plane request must carry the CLI's version (#996): the server's
+// version floor only judges requests that have it, so a hand-built header object
+// that omits it silently exempts that call from both the advisory and an
+// enforced floor. Spread this into any headers literal that bypasses
+// apiRequest/jsonHeaders.
+function cliVersionHeader() {
+    return { "x-9pm-cli-version": CLI_VERSION };
+}
 async function expectJson(response, action) {
     await expectOk(response, action);
     return (await response.json());
 }
 async function expectOk(response, action) {
+    noteCliOutdatedAdvisory(response);
     if (response.ok) {
         return;
     }
+    // 426 is the control plane's enforced CLI floor (#996): the server-written
+    // message IS the response — surface it alone rather than burying it in the
+    // raw envelope the generic path prints.
+    if (response.status === 426) {
+        throw new Error(await apiErrorMessage(response, action));
+    }
     const text = await response.text();
     throw new Error(`Failed to ${action}: ${response.status} ${text}`);
 }
+// Advisory half of the control plane's CLI floor (#996): when a response says
+// this version is below the platform's recommended minimum, say so once per
+// invocation, on stderr so command output (including --json) stays parseable.
+const CLI_OUTDATED_HEADER = "x-9pm-cli-outdated";
+let cliOutdatedAdvisoryPrinted = false;
+export function noteCliOutdatedAdvisory(response, log = (line) => console.error(line)) {
+    if (cliOutdatedAdvisoryPrinted) {
+        return;
+    }
+    const min = response.headers.get(CLI_OUTDATED_HEADER);
+    if (!min) {
+        return;
+    }
+    cliOutdatedAdvisoryPrinted = true;
+    log(`Note: this CLI (${CLI_VERSION}) is older than the platform's recommended minimum (${min}). Update: npm i -g ninepm@latest`);
+}
+// Test seam: the once-per-invocation latch above is module state, which one
+// test process shares across cases.
+export function resetCliOutdatedAdvisoryForTests() {
+    cliOutdatedAdvisoryPrinted = false;
+}
 // Pull the control plane's own message out of its {error:{code,message}} envelope,
 // for the few refusals whose message is written for the tester and is the whole
 // point of the response (e.g. device signup being unavailable, #507). Dumping the
@@ -3686,6 +3853,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 +4336,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.52.0",
   "description": "CLI for deploying built apps to 9pm.ai.",
   "homepage": "https://9pm.ai",
   "keywords": [