@trypattern/sdk 0.1.22 → 0.1.23

package/dist/cli/app.js

@@ -23,6 +23,7 @@ import { addLiveMedia, login, publish, pull, restore, versions as listVersions }
 import { CHANGE_SET_ROWS } from "../publishWire.js";
 import { DATA_USAGE, data } from "./data.js";
 import { toolBin } from "./tools.js";
+import { isNewer, latestPattern, newerPattern, updateNote } from "./updates.js";
 function dependsOnPattern(directory) {
     try {
         const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
@@ -80,6 +81,7 @@ const CONTACT_SHEET = join(SCREENSHOTS_DIR, 'contact-sheet.png');
 const SCREENSHOT_WORKER = join(SDK_SOURCE, 'cli', `screenshot${SDK_EXTENSION}`);
 const VISUAL_URL_ENV = 'PATTERN_VISUAL_URL';
 const GLOBAL_FLAGS = ['--json', '--help', '-h'];
+const NUDGED_COMMANDS = new Set(['start', 'check', 'publish', 'data']);
 const VALUE_FLAGS = new Set([
     '--commands',
     '--name',
@@ -373,6 +375,15 @@ collected changes. Up to ${CHANGE_SET_ROWS} changes per request. For this comput
         argumentCount: 3,
         flags: ['--row', '--set', '--file', '--asked']
     },
+    update: {
+        summary: 'Bring this project to the newest Pattern',
+        details: `Installs the newest @trypattern/sdk from npm into this project (pnpm add, exact version).
+start, check, publish and data say when a newer Pattern is out. The live site keeps the old one until
+the next app publish, so run app check, then publish it (straight away when nothing else is in
+progress). New Pattern features on the live site, such as the owner approving app data changes,
+need that publish.`,
+        run: update
+    },
     versions: {
         summary: 'List the versions that went live, newest first',
         details: 'Each version with its number, whether it went live, when, and who published it. app restore <number> puts one back.',
@@ -1492,6 +1503,43 @@ function installShim() {
         path: SHIM_PATH
     };
 }
+async function update() {
+    const current = sdkVersion();
+    const latest = await latestPattern(true);
+    if (latest === undefined) {
+        return {
+            code: 1,
+            data: { current, error: 'npm did not answer' },
+            text: '✗ Couldn’t reach npm to find the newest Pattern. Check the internet connection and try again.'
+        };
+    }
+    if (!isNewer(latest, current)) {
+        return {
+            code: 0,
+            data: { current, latest, updated: false },
+            text: `✓ Pattern is up to date (${current})`
+        };
+    }
+    say(`Updating Pattern ${current} → ${latest}`);
+    const installed = await capture('pnpm', ['add', `@trypattern/sdk@${latest}`]);
+    if (installed.code !== 0) {
+        return {
+            code: 1,
+            data: {
+                current,
+                latest,
+                error: 'pnpm add failed',
+                output: installed.output
+            },
+            text: `✗ pnpm couldn’t install Pattern ${latest}:\n${installed.output.trim().split('\n').slice(-LOG_TAIL_LINES).join('\n')}`
+        };
+    }
+    return {
+        code: 0,
+        data: { current, latest, updated: true },
+        text: `✓ Updated Pattern ${current} → ${latest}\n  next  run app check, then app publish --message 'Updated Pattern' (straight away if nothing else is in progress) so the live site gets it`
+    };
+}
 async function setup() {
     const pins = readPins();
     const haveNode = process.versions.node;
@@ -1635,6 +1683,16 @@ async function main(argv) {
     }
     else {
         outcome = await command.run(positional[1], options, positional.slice(1));
+        if (NUDGED_COMMANDS.has(name)) {
+            const latest = await newerPattern(sdkVersion());
+            if (latest !== undefined) {
+                outcome = {
+                    ...outcome,
+                    data: { ...outcome.data, newerPattern: latest },
+                    text: `${outcome.text}\n${updateNote(latest, sdkVersion())}`
+                };
+            }
+        }
     }
     if (jsonMode) {
         const payload = {

package/dist/cli/updates.d.ts

@@ -0,0 +1,4 @@
+export declare function isNewer(candidate: string, current: string): boolean;
+export declare function latestPattern(fresh?: boolean): Promise<string | undefined>;
+export declare function newerPattern(current: string): Promise<string | undefined>;
+export declare function updateNote(latest: string, current: string): string;

package/dist/cli/updates.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+const LATEST_URL = 'https://registry.npmjs.org/@trypattern/sdk/latest';
+const CACHE_FILE = join(homedir(), '.config', 'pattern', 'latest-sdk.json');
+const CHECK_MS = 6 * 3_600_000;
+const TIMEOUT_MS = 1500;
+const cached = z.object({ version: z.string(), checkedAt: z.number() });
+const published = z.object({ version: z.string() });
+function partsOf(version) {
+    return (version
+        .split('-')[0]
+        ?.split('.')
+        .map((part) => Number.parseInt(part, 10) || 0) ?? [0]);
+}
+export function isNewer(candidate, current) {
+    const next = partsOf(candidate);
+    const now = partsOf(current);
+    for (let index = 0; index < Math.max(next.length, now.length); index += 1) {
+        const difference = (next[index] ?? 0) - (now[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0;
+    }
+    return false;
+}
+function readCache() {
+    if (!existsSync(CACHE_FILE))
+        return undefined;
+    try {
+        const parsed = cached.safeParse(JSON.parse(readFileSync(CACHE_FILE, 'utf8')));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function latestPattern(fresh = false) {
+    const remembered = readCache();
+    if (!fresh &&
+        remembered !== undefined &&
+        Date.now() - remembered.checkedAt < CHECK_MS) {
+        return remembered.version;
+    }
+    try {
+        const response = await fetch(LATEST_URL, {
+            signal: AbortSignal.timeout(TIMEOUT_MS)
+        });
+        const body = published.safeParse(await response.json());
+        if (!response.ok || !body.success)
+            return remembered?.version;
+        mkdirSync(dirname(CACHE_FILE), { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify({ version: body.data.version, checkedAt: Date.now() }));
+        return body.data.version;
+    }
+    catch {
+        return remembered?.version;
+    }
+}
+export async function newerPattern(current) {
+    if (process.env['PATTERN_NO_UPDATE_CHECK'] !== undefined)
+        return undefined;
+    const latest = await latestPattern();
+    return latest !== undefined && isNewer(latest, current) ? latest : undefined;
+}
+export function updateNote(latest, current) {
+    return `  update  Pattern ${latest} is out (this project has ${current}). Run app update now, then app check. Publish it straight away if nothing else is in progress, otherwise with the next publish, so the live site gets it too. Tell the owner in a few words.`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "type": "module",
   "files": [
     "dist",