pi-updater 0.2.8 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 0.3.0 - 2026-03-23
+
+- Auto-restart pi after a successful update. Asks to restart, then seamlessly relaunches on the current session.
+- Falls back to manual restart message in non-interactive modes or if restart fails.
+- Cross-platform: uses `shell: true` on Windows to handle `.cmd` shims.
+- `/update --test` to simulate the full update flow without a real install.
+
+## 0.2.9 - 2026-03-16
+
+- Keep startup checks cache-first and non-blocking.
+- Add a one-time background live check per run.
+- Show update prompt in the same session when the background check finds a newer version.
+- Respect `PI_SKIP_VERSION_CHECK` and `PI_OFFLINE` for automatic checks.
+- Avoid duplicate automatic prompts for the same version in one run.
+- `/update` now warns and exits early when `PI_OFFLINE` is set.

package/README.md

@@ -1,21 +1,35 @@
 # pi-updater
 
-A Codex-style auto-updater for Pi.
+A lightweight, Codex-style auto-updater for pi with fast, cache-first startup checks.
 
-> **Note:** Currently supports npm installations only.
+- npm: https://www.npmjs.com/package/pi-updater
+- repo: https://github.com/tonze/pi-updater
+
+> **Note:** Automatic installation currently supports npm-based pi installs only.
 
 <img width="800" height="482" alt="Screenshot 2026-02-28 at 09 01 37" src="https://github.com/user-attachments/assets/89df2dad-8d91-464b-b3cb-dfd15bce1c06" />
 
 ## What it does
 
 **On startup:** if a newer version is available, shows a prompt:
-- **Update now** — install with npm, then restart pi
+- **Update now** — install with npm, then auto-restart pi on the current session
 - **Skip** — dismiss until next session
 - **Skip this version** — don't ask again until a newer version appears
 
-**`/update`:** manually check for updates (always fetches fresh from npm)
+After a successful update, pi-updater asks whether to restart immediately. If confirmed, pi relaunches seamlessly on the current session. In non-interactive modes or if auto-restart fails, it falls back to a manual restart message.
+
+**In the background (once per run):** performs one live npm check and can show the prompt in the same session when a new release is detected.
+
+**`/update`:** manually check for updates (always fetches fresh from npm, unless `PI_OFFLINE` is set).
+
+## How version checks work
 
-Version checks are cached. Latest version is fetched in the background on startup.
+pi-updater uses a cache-first approach to keep startup fast:
+
+1. On startup, cached version data is checked instantly.
+2. One background live fetch refreshes the cache.
+3. If the background fetch finds a newer version, pi-updater can prompt in the same session.
+4. Automatic checks are skipped when `PI_SKIP_VERSION_CHECK` or `PI_OFFLINE` is set.
 
 ## Install
 
@@ -33,6 +47,20 @@ pi install git:github.com/tonze/pi-updater
 
 Use `/update` inside pi to manually check for updates and install them.
 
+## Environment flags
+
+Disable automatic version checks:
+
+```bash
+export PI_SKIP_VERSION_CHECK=1
+```
+
+Or run in offline mode (also disables automatic checks):
+
+```bash
+export PI_OFFLINE=1
+```
+
 ## Updating this package
 
 ```bash

package/index.ts

@@ -3,6 +3,7 @@ import type {
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { VERSION, BorderedLoader } from "@mariozechner/pi-coding-agent";
+import { spawnSync } from "node:child_process";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
@@ -11,9 +12,13 @@ const PACKAGE_NAME = "@mariozechner/pi-coding-agent";
 const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 const CACHE_FILE = join(homedir(), ".pi", "agent", "update-cache.json");
 
+const ENV_SKIP_VERSION_CHECK = "PI_SKIP_VERSION_CHECK";
+const ENV_OFFLINE = "PI_OFFLINE";
+
 interface VersionCache {
   latestVersion: string;
   dismissedVersion?: string;
+  checkedAt?: string;
 }
 
 function readCache(): VersionCache | undefined {
@@ -48,6 +53,27 @@ function isNewer(latest: string, current: string): boolean {
   return l[2] > c[2];
 }
 
+function isEnvSet(name: string): boolean {
+  return Boolean(process.env[name]);
+}
+
+function shouldSkipAutoChecks(): boolean {
+  return isEnvSet(ENV_SKIP_VERSION_CHECK) || isEnvSet(ENV_OFFLINE);
+}
+
+function isOffline(): boolean {
+  return isEnvSet(ENV_OFFLINE);
+}
+
+function saveLatestToCache(latest: string) {
+  const prev = readCache();
+  writeCache({
+    latestVersion: latest,
+    dismissedVersion: prev?.dismissedVersion,
+    checkedAt: new Date().toISOString(),
+  });
+}
+
 async function fetchLatestVersion(): Promise<string | undefined> {
   try {
     const res = await fetch(REGISTRY_URL, {
@@ -60,33 +86,30 @@ async function fetchLatestVersion(): Promise<string | undefined> {
   }
 }
 
-/**
- * Returns the cached latest version if an upgrade is available and not dismissed.
- * Always kicks off a background fetch to refresh the cache for the next run.
- */
-function getUpgradeVersion(): string | undefined {
+/** Returns a cached upgrade if available and not dismissed. */
+function getCachedUpgradeVersion(): string | undefined {
   const cache = readCache();
-
-  void fetchLatestVersion().then((latest) => {
-    if (!latest) return;
-    // Re-read cache to avoid overwriting a dismissal that happened during the fetch
-    writeCache({
-      latestVersion: latest,
-      dismissedVersion: readCache()?.dismissedVersion,
-    });
-  });
-
   if (!cache) return undefined;
   if (!isNewer(cache.latestVersion, VERSION)) return undefined;
   if (cache.dismissedVersion === cache.latestVersion) return undefined;
   return cache.latestVersion;
 }
 
+/** Fetch latest from npm and refresh cache. */
+async function refreshLatestVersionInCache(): Promise<string | undefined> {
+  const latest = await fetchLatestVersion();
+  if (!latest) return undefined;
+  saveLatestToCache(latest);
+  return latest;
+}
+
 function dismissVersion(version: string) {
   const cache = readCache();
-  if (!cache) return;
-  cache.dismissedVersion = version;
-  writeCache(cache);
+  writeCache({
+    latestVersion: cache?.latestVersion ?? version,
+    dismissedVersion: version,
+    checkedAt: cache?.checkedAt,
+  });
 }
 
 function getInstallCommand(version: string): { program: string; args: string[] } {
@@ -101,6 +124,44 @@ function fmtCmd(cmd: { program: string; args: string[] }): string {
 }
 
 export default function (pi: ExtensionAPI) {
+  let promptOpen = false;
+  const promptedVersions = new Set<string>();
+  let liveCheckStarted = false;
+
+  async function findPiBinary(): Promise<string> {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const result = await pi.exec(cmd, ["pi"]);
+    if (result.code === 0 && result.stdout?.trim()) {
+      return result.stdout.trim().split(/\r?\n/)[0];
+    }
+    return "pi";
+  }
+
+  function canAutoRestart(ctx: ExtensionContext): boolean {
+    return ctx.hasUI && !!process.stdin.isTTY && !!process.stdout.isTTY;
+  }
+
+  async function restartPi(ctx: ExtensionContext): Promise<boolean> {
+    const piBinary = await findPiBinary();
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    const restartArgs = sessionFile ? ["--session", sessionFile] : ["-c"];
+
+    return ctx.ui.custom<boolean>((tui, _theme, _kb, done) => {
+      tui.stop();
+      const result = spawnSync(piBinary, restartArgs, {
+        cwd: ctx.cwd,
+        env: process.env,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        windowsHide: false,
+      });
+      tui.start();
+      tui.requestRender(true);
+      done(!result.error && (result.status === null || result.status === 0));
+      return { render: () => [], invalidate: () => {} };
+    });
+  }
+
   async function doInstall(
     ctx: ExtensionContext,
     latest: string,
@@ -110,37 +171,50 @@ export default function (pi: ExtensionAPI) {
       const loader = new BorderedLoader(tui, theme, `Installing ${latest}...`);
       loader.onAbort = () => done(false);
 
-      const run = async () => {
-        if (cmd.program === "echo") {
-          ctx.ui.notify(cmd.args[0], "info");
-          return false;
-        }
-        const result = await pi.exec(cmd.program, cmd.args, {
-          timeout: 120_000,
-        });
-        if (result.code !== 0) {
-          ctx.ui.notify(
-            `Update failed (exit ${result.code}): ${result.stderr || result.stdout}`,
-            "error",
-          );
-          return false;
-        }
-        return true;
-      };
-
-      run()
-        .then(done)
+      pi.exec(cmd.program, cmd.args, { timeout: 120_000 })
+        .then((result) => {
+          if (result.code !== 0) {
+            ctx.ui.notify(
+              `Update failed (exit ${result.code}): ${result.stderr || result.stdout}`,
+              "error",
+            );
+            done(false);
+          } else {
+            done(true);
+          }
+        })
         .catch(() => done(false));
+
       return loader;
     });
 
     if (!success) return;
 
-    const ok = await ctx.ui.confirm(
+    if (!canAutoRestart(ctx)) {
+      ctx.ui.notify(
+        `Updated to ${latest}! Please restart pi.\nTip: run \`pi -c\` to continue this session.`,
+        "info",
+      );
+      return;
+    }
+
+    const restart = await ctx.ui.confirm(
       `Updated to ${latest}!`,
-      "Shut down pi? (Use pi -c to continue this session)",
+      "Restart now?",
+    );
+
+    if (!restart) return;
+
+    const ok = await restartPi(ctx);
+    if (ok) {
+      ctx.shutdown();
+      return;
+    }
+
+    ctx.ui.notify(
+      `Updated to ${latest}! Auto-restart failed. Please restart pi manually.\nTip: run \`pi -c\` to continue this session.`,
+      "error",
     );
-    if (ok) ctx.shutdown();
   }
 
   async function showUpdatePrompt(ctx: ExtensionContext, latest: string) {
@@ -159,21 +233,96 @@ export default function (pi: ExtensionAPI) {
     await doInstall(ctx, latest, cmd);
   }
 
-  pi.on("session_start", async (_event, ctx) => {
+  function canAutoPromptVersion(latest: string): boolean {
+    if (!isNewer(latest, VERSION)) return false;
+    if (promptedVersions.has(latest)) return false;
+    if (readCache()?.dismissedVersion === latest) return false;
+    return true;
+  }
+
+  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: string) {
     if (!ctx.hasUI) return;
-    const latest = getUpgradeVersion();
-    if (latest) void showUpdatePrompt(ctx, latest);
+    if (promptOpen) return;
+    if (!canAutoPromptVersion(latest)) return;
+
+    promptOpen = true;
+    promptedVersions.add(latest);
+    try {
+      await showUpdatePrompt(ctx, latest);
+    } finally {
+      promptOpen = false;
+    }
+  }
+
+  function runAutoChecks(ctx: ExtensionContext) {
+    if (!ctx.hasUI) return;
+    if (shouldSkipAutoChecks()) return;
+
+    const cached = getCachedUpgradeVersion();
+    if (cached) void maybeShowAutoPrompt(ctx, cached);
+
+    if (liveCheckStarted) return;
+    liveCheckStarted = true;
+
+    void refreshLatestVersionInCache()
+      .then((latest) => {
+        if (!latest) return;
+        void maybeShowAutoPrompt(ctx, latest);
+      })
+      .catch(() => {});
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    runAutoChecks(ctx);
   });
 
   pi.on("session_switch", async (_event, ctx) => {
-    if (!ctx.hasUI) return;
-    const latest = getUpgradeVersion();
-    if (latest) void showUpdatePrompt(ctx, latest);
+    runAutoChecks(ctx);
   });
 
   pi.registerCommand("update", {
     description: "Check for pi updates and install",
-    handler: async (_args, ctx) => {
+    handler: async (rawArgs, ctx) => {
+      // /update --test — simulate the full UI flow without a real install
+      if (rawArgs?.trim() === "--test") {
+        const fakeLatest = "99.0.0";
+        const cmd = getInstallCommand(fakeLatest);
+        const choice = await ctx.ui.select(`Update ${VERSION} → ${fakeLatest}`, [
+          `Update now (${fmtCmd(cmd)})`,
+          "Skip",
+          "Skip this version",
+        ]);
+        if (!choice || choice === "Skip" || choice === "Skip this version") return;
+
+        await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+          const loader = new BorderedLoader(tui, theme, `Installing ${fakeLatest}...`);
+          loader.onAbort = () => done();
+          setTimeout(() => done(), 1500);
+          return loader;
+        });
+
+        if (!canAutoRestart(ctx)) {
+          ctx.ui.notify(`Updated to ${fakeLatest}! Please restart pi.`, "info");
+          return;
+        }
+
+        const restart = await ctx.ui.confirm(`Updated to ${fakeLatest}!`, "Restart now?");
+        if (!restart) return;
+
+        const ok = await restartPi(ctx);
+        if (ok) { ctx.shutdown(); return; }
+        ctx.ui.notify("Test restart failed.", "error");
+        return;
+      }
+
+      if (isOffline()) {
+        ctx.ui.notify(
+          "PI_OFFLINE is set. Disable it to check for updates.",
+          "warning",
+        );
+        return;
+      }
+
       const latest = await ctx.ui.custom<string | null>(
         (tui, theme, _kb, done) => {
           const loader = new BorderedLoader(
@@ -194,16 +343,14 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      writeCache({
-        latestVersion: latest,
-        dismissedVersion: readCache()?.dismissedVersion,
-      });
+      saveLatestToCache(latest);
 
       if (!isNewer(latest, VERSION)) {
         ctx.ui.notify(`Already on latest version (${VERSION}).`, "info");
         return;
       }
 
+      promptedVersions.add(latest);
       await showUpdatePrompt(ctx, latest);
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-updater",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Codex-style auto-updater for pi. Checks for new versions on startup and prompts to install.",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,8 @@
   },
   "files": [
     "index.ts",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*"