pi-updater 0.3.2 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.4.0 - 2026-07-05
+
+- Detect outdated extension packages (same check as pi's "Package Updates Available" banner) and offer to update them interactively.
+- Combined prompt when both pi and extensions are outdated: "Update all" (`pi update --self --extensions`), pi only, or extensions only.
+- Extensions-only prompt when pi is current but packages are outdated: runs `pi update --extensions`, then hot-reloads via `ctx.reload()` (from `/update`) or restarts into the same session (from the startup prompt, which cannot trigger a reload).
+- Selecting an update option is the only interaction: no separate restart confirmation afterwards, and the restarted pi skips its startup check once so partial updates don't immediately re-prompt.
+- Startup shows one consolidated prompt after both checks resolve (never a partial offer); the cached pi version is now only a fallback for failed fetches.
+- `/update` now checks both pi and extension packages.
+- Raise install timeout to 5 minutes to accommodate multi-package updates.
+- Treat killed (timed-out) update processes as failures so a partial install never reloads or restarts as success.
+- Use `pi update --self --extensions` instead of `--all` for compatibility with pi < 0.80.
+- Version dismissal is now "Ignore <version>" and only offered in the pi-only prompt.
+
+## 0.3.4 - 2026-07-05 (not published to npm; included in 0.4.0)
+
+- Delegate installs to pi's native `pi update --self` command so npm, pnpm, yarn, bun, and standalone installs use pi's own update logic.
+- Remove the npm-only package migration installer now that the legacy package migration window is closed.
+- Remove all legacy `@mariozechner` support: static `@earendil-works/pi-coding-agent` import, no owning-package detection, no package-name tracking in the cache. Requires pi 0.74.0+ (`@earendil-works` scope); older installs can pin `pi-updater@0.3.3`.
+- Keep pi-updater focused on the interactive prompt, cache-first update checks, and auto-restart flow.
+
+## 0.3.3 - 2026-05-21
+
+- Honor the update service `packageName` and install the explicit advertised npm package/version.
+- Avoid native `pi update --self` so pi-updater can update through stale native self-update behavior.
+- Keep loading under the legacy `@mariozechner/pi-coding-agent` runtime so package-name migrations can run.
+- Migrate the global pi binary when the update service advertises a new package name by force-installing the advertised package after an engine-strict dry run.
+- Treat package-name-only migrations as updates only when the advertised version is unchanged or newer, while staying on the current package if `packageName` is absent.
+- Respect npm engine requirements during pi installs so updates fail safely when Node.js is too old.
+- Switch extension imports and optional peer dependency to `@earendil-works/pi-coding-agent` so installing pi-updater no longer pulls the old `@mariozechner` pi package.
+
 ## 0.3.2 - 2026-05-02
 
 - Use pi's native `pi update --self` installer on pi 0.70.3+ and keep npm install as the fallback for older pi versions.

package/README.md

@@ -1,72 +1,122 @@
 # pi-updater
 
-A lightweight, Codex-style auto-updater for pi with fast, cache-first startup checks.
+pi-updater is a [pi](https://pi.dev) extension that turns pi's update notices
+into an interactive flow: it prompts you when a new pi version or extension
+package updates are available, installs them without leaving your session,
+and puts you right back where you were.
 
 - npm: https://www.npmjs.com/package/pi-updater
 - repo: https://github.com/tonze/pi-updater
 
-> **Note:** On pi 0.70.3+, pi-updater delegates installation to pi's native `pi update --self` command. Older pi versions fall back to npm-based installation.
-
 <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
+## Why does this exist?
 
-**On pi 0.70.3+:** pi-updater is native-aware. It keeps the interactive startup update prompt, checks pi's update service, installs with `pi update --self`, then offers to restart the current session. Pi's built-in updater only shows a notice with a command to run; pi-updater provides the clickable update/restart flow.
+pi already checks for updates on startup — for itself and for installed
+extension packages — but all it does is print a notice telling you which
+command to run. The built-in flow is: see the notice, finish what you're
+doing, quit pi, run `pi update`, start pi again, run `pi -c` to get your
+session back. That's five steps for something that should be one keypress.
 
-**On older pi versions:** if a newer version is available, pi-updater shows a startup prompt:
-- **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
+pi-updater collapses this into a prompt. Choose an update option and it
+installs the new versions and puts you back in your current session. You can
+also skip once, or skip a specific pi version so it stops asking until the
+next release.
 
-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. Ephemeral `--no-session` runs stay ephemeral on restart.
+The actual installation is delegated to pi's native `pi update` command. pi
+knows how it was installed (npm, pnpm, yarn, bun, or a standalone binary)
+and what extension packages you have configured; pi-updater deliberately
+does not reimplement any of that. This extension owns the interactive
+experience, nothing more.
 
-**`/update`:** manually check for updates (always fetches fresh from pi's update service, unless `PI_OFFLINE` is set). On pi 0.70.3+ it installs with `pi update --self`; on older pi it falls back to npm.
+## Installation
 
-## How version checks work
+```bash
+pi install npm:pi-updater
+```
 
-pi-updater uses a cache-first approach to keep startup fast:
+Requires pi 0.74.0 or later (the `@earendil-works` package scope). On older
+installs the extension fails to load harmlessly; if you need it there, pin
+`pi-updater@0.3.3`.
 
-1. On startup, cached version data is checked instantly.
-2. One background live fetch refreshes the cache from pi's update service.
-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.
+## Usage
 
-## Install
+There is nothing to configure. On startup, pi-updater checks both pi itself
+and your installed extension packages (the same check behind pi's "Package
+Updates Available" banner).
 
-```bash
-pi install npm:pi-updater
-```
+If only pi is outdated:
 
-Or from git:
+- **Update now** — run `pi update --self`, then restart pi on the current session
+- **Skip** — ask again next session
+- **Ignore \<version\>** — don't ask again until a newer version appears
 
-```bash
-pi install git:github.com/tonze/pi-updater
-```
+If both pi and extensions are outdated, a combined prompt appears:
 
-## Usage
+- **Update all** — run `pi update --self --extensions`, then restart
+- **Skip** — ask again next session
+- **Update pi only** — run `pi update --self`, then restart
+- **Update extensions only** — run `pi update --extensions`, then reload
 
-Use `/update` inside pi to manually check for updates and install them.
+Version dismissal ("Ignore") is only offered in the pi-only prompt; a
+dismissed pi version degrades the combined prompt to extensions-only.
 
-Cache and dismissed-version state are stored in pi's configured agent directory and respect `PI_CODING_AGENT_DIR`.
+If only extensions are outdated, you're offered `pi update --extensions`.
 
-## Environment flags
+Choosing an update option is the only interaction: anything involving pi
+core restarts straight back into your current session, and extension-only
+updates are hot-reloaded in place (from the startup prompt, where extensions
+cannot trigger a reload, pi restarts into the session instead — same
+result). Either way you keep working where you left off.
 
-Disable automatic version checks:
+You can also check manually at any time with `/update`.
 
-```bash
-export PI_SKIP_VERSION_CHECK=1
-```
+Extension updates have no per-version skip; choosing Skip simply asks again
+next session. Pinned (`@version` / `#ref`) and local packages are excluded,
+matching pi's own update check.
+
+In non-interactive modes, or if the restart fails, pi-updater falls back to
+a message telling you how to restart yourself. Ephemeral `--no-session` runs
+stay ephemeral across the restart.
+
+### How version checks work
+
+Startup is never blocked. Both checks run in the background — pi's version
+against pi's update service, extension packages against their npm/git
+sources — and one consolidated prompt appears when they resolve, so you are
+never offered a partial update. If the version fetch fails, a previously
+cached result is used as fallback. After an update restarts pi, the startup
+check is skipped once so you're not immediately re-prompted for anything you
+just declined.
 
-Or run in offline mode (also disables automatic checks):
+`/update` always fetches fresh. Cache and dismissed-version state live in pi's
+agent directory and respect `PI_CODING_AGENT_DIR`.
+
+### Disabling checks
+
+pi's standard environment variables are respected:
 
 ```bash
-export PI_OFFLINE=1
+export PI_SKIP_VERSION_CHECK=1   # disable automatic checks
+export PI_OFFLINE=1              # offline mode, also disables checks
 ```
 
-## Updating this package
+While pi-updater is active it suppresses pi's built-in update notice so you
+don't get prompted twice for the same release. pi's "Package Updates
+Available" banner cannot be suppressed the same way, so it may still appear
+alongside pi-updater's extension prompt.
+
+## Caveats
+
+Because installation is delegated to pi, pi's limitations apply: standalone
+binary installs get download instructions instead of an automatic install, and
+Windows self-update covers npm and pnpm installs only. In those cases you'll
+see pi's own message explaining what to do.
+
+## Updating pi-updater itself
 
 ```bash
-pi update
+pi update npm:pi-updater
 ```
 
 ## License

package/index.ts

@@ -1,20 +1,35 @@
 import type {
   ExtensionAPI,
   ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { VERSION, BorderedLoader, getAgentDir } from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
+import { VERSION, BorderedLoader, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { spawnSync } from "node:child_process";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 
-const PACKAGE_NAME = "@mariozechner/pi-coding-agent";
 const LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
-const NATIVE_SELF_UPDATE_MIN_VERSION = "0.70.3";
 const CACHE_FILE = join(getAgentDir(), "update-cache.json");
+const UPDATE_COMMANDS = {
+  self: { args: ["update", "--self"], display: "pi update --self" },
+  extensions: { args: ["update", "--extensions"], display: "pi update --extensions" },
+  // --self --extensions rather than --all: pi < 0.80 doesn't parse --all,
+  // but the flag pair resolves to the "all" target on every supported version.
+  all: { args: ["update", "--self", "--extensions"], display: "pi update --self --extensions" },
+} as const;
+
+type UpdateTarget = keyof typeof UPDATE_COMMANDS;
+
+interface UpdateOffer {
+  piLatest?: string;
+  extensions: string[];
+}
 
 const ENV_SKIP_VERSION_CHECK = "PI_SKIP_VERSION_CHECK";
 const ENV_OFFLINE = "PI_OFFLINE";
 const ENV_INTERNAL_SKIP = "PI_UPDATER_SUPPRESSED_NATIVE_VERSION_CHECK";
+// One-shot: set on the pi process we restart into after an update, so the
+// user is not immediately re-prompted for updates they just declined.
+const ENV_SUPPRESS_STARTUP_CHECK = "PI_UPDATER_SUPPRESS_STARTUP_CHECK";
 
 interface VersionCache {
   latestVersion: string;
@@ -57,27 +72,17 @@ function parseVersion(version: string): ParsedVersion | undefined {
   };
 }
 
-function compareVersions(leftVersion: string, rightVersion: string): number | undefined {
-  const left = parseVersion(leftVersion);
-  const right = parseVersion(rightVersion);
-  if (!left || !right) return undefined;
-  if (left.major !== right.major) return left.major - right.major;
-  if (left.minor !== right.minor) return left.minor - right.minor;
-  if (left.patch !== right.patch) return left.patch - right.patch;
-  if (left.prerelease === right.prerelease) return 0;
-  if (!left.prerelease) return 1;
-  if (!right.prerelease) return -1;
-  return left.prerelease.localeCompare(right.prerelease);
-}
-
-function isNewer(latest: string, current: string): boolean {
-  const comparison = compareVersions(latest, current);
-  return comparison !== undefined && comparison > 0;
-}
-
-function isAtLeast(version: string, minimum: string): boolean {
-  const comparison = compareVersions(version, minimum);
-  return comparison !== undefined && comparison >= 0;
+function isNewer(candidate: string, current: string): boolean {
+  const left = parseVersion(candidate);
+  const right = parseVersion(current);
+  if (!left || !right) return false;
+  if (left.major !== right.major) return left.major > right.major;
+  if (left.minor !== right.minor) return left.minor > right.minor;
+  if (left.patch !== right.patch) return left.patch > right.patch;
+  if (left.prerelease === right.prerelease) return false;
+  if (!left.prerelease) return true;
+  if (!right.prerelease) return false;
+  return left.prerelease.localeCompare(right.prerelease) > 0;
 }
 
 function isEnvSet(name: string): boolean {
@@ -102,19 +107,6 @@ function piUserAgent(): string {
   return `pi/${VERSION} (${process.platform}; ${runtime}; ${process.arch})`;
 }
 
-function hasNativeSelfUpdate(): boolean {
-  return isAtLeast(VERSION, NATIVE_SELF_UPDATE_MIN_VERSION);
-}
-
-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(LATEST_VERSION_URL, {
@@ -125,16 +117,46 @@ async function fetchLatestVersion(): Promise<string | undefined> {
       signal: AbortSignal.timeout(10_000),
     });
     if (!res.ok) return undefined;
-    const version = ((await res.json()) as { version?: string }).version;
-    return typeof version === "string" && version.trim()
-      ? version.trim()
-      : undefined;
+    const data = (await res.json()) as { version?: string };
+    if (typeof data.version !== "string" || !data.version.trim()) return undefined;
+    return data.version.trim();
   } catch {
     return undefined;
   }
 }
 
-/** Returns a cached upgrade if available and not dismissed. */
+/**
+ * Check for outdated extension packages using pi's own package manager —
+ * the same code path behind pi's startup "Package Updates Available" banner.
+ * These exports are not documented extension API, so degrade gracefully.
+ */
+async function checkForExtensionUpdates(cwd: string): Promise<string[]> {
+  try {
+    const mod = (await import("@earendil-works/pi-coding-agent")) as Record<string, any>;
+    const { DefaultPackageManager, SettingsManager } = mod;
+    if (
+      typeof DefaultPackageManager !== "function" ||
+      typeof SettingsManager?.create !== "function"
+    ) {
+      return [];
+    }
+    const agentDir = getAgentDir();
+    const packageManager = new DefaultPackageManager({
+      cwd,
+      agentDir,
+      settingsManager: SettingsManager.create(cwd, agentDir),
+    });
+    const updates = await packageManager.checkForAvailableUpdates();
+    if (!Array.isArray(updates)) return [];
+    return updates
+      .map((update) => String(update?.displayName ?? update?.source ?? ""))
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** Returns a cached upgrade version if available and not dismissed. */
 function getCachedUpgradeVersion(): string | undefined {
   const cache = readCache();
   if (!cache) return undefined;
@@ -143,6 +165,15 @@ function getCachedUpgradeVersion(): string | undefined {
   return cache.latestVersion;
 }
 
+function saveLatestToCache(latest: string) {
+  const prev = readCache();
+  writeCache({
+    latestVersion: latest,
+    dismissedVersion: prev?.dismissedVersion,
+    checkedAt: new Date().toISOString(),
+  });
+}
+
 /** Fetch latest from Pi's update endpoint and refresh cache. */
 async function refreshLatestVersionInCache(): Promise<string | undefined> {
   const latest = await fetchLatestVersion();
@@ -160,34 +191,65 @@ function dismissVersion(version: string) {
   });
 }
 
-interface InstallCommand {
-  program: string;
-  args: string[];
-  display: string;
+function isBunFsPath(path: string): boolean {
+  return path.includes("$bunfs") || path.includes("~BUN") || path.includes("%7EBUN");
 }
 
-function getInstallCommand(version: string): InstallCommand {
-  if (hasNativeSelfUpdate()) {
-    return {
-      program: "pi",
-      args: ["update", "--self"],
-      display: "pi update --self",
-    };
+/**
+ * Command that re-invokes the currently running pi, regardless of what
+ * `pi` on PATH points to. For Node installs this is `node <entrypoint>`;
+ * for Bun standalone binaries the executable itself is pi.
+ */
+function currentPiCommand(args: string[]): { program: string; args: string[] } {
+  const entry = process.argv[1];
+  if (entry && !isBunFsPath(entry)) {
+    return { program: process.execPath, args: [entry, ...args] };
   }
+  return { program: process.execPath, args };
+}
 
-  return {
-    program: "npm",
-    args: ["install", "-g", `${PACKAGE_NAME}@${version}`],
-    display: `npm install -g ${PACKAGE_NAME}@${version}`,
-  };
+interface InstallFailure {
+  code: number;
+  output: string;
 }
 
-function fmtCmd(cmd: InstallCommand): string {
-  return cmd.display;
+function formatInstallFailure(failure: InstallFailure, display: string): string {
+  return `Update failed while running \`${display}\` (exit ${failure.code})${failure.output ? `: ${failure.output}` : ""}`;
+}
+
+async function runNativeUpdate(
+  pi: ExtensionAPI,
+  target: UpdateTarget,
+): Promise<InstallFailure | undefined> {
+  const previousSkip = process.env[ENV_SKIP_VERSION_CHECK];
+  const previousInternalSkip = process.env[ENV_INTERNAL_SKIP];
+  delete process.env[ENV_SKIP_VERSION_CHECK];
+  delete process.env[ENV_INTERNAL_SKIP];
+
+  try {
+    const cmd = currentPiCommand([...UPDATE_COMMANDS[target].args]);
+    const result = await pi.exec(cmd.program, cmd.args, { timeout: 300_000 });
+    // A timed-out process is killed and can report exit code 0; treat it as failure.
+    if (result.killed || result.code !== 0) {
+      const output = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+      return {
+        code: result.code,
+        output: result.killed ? ["Update timed out after 5 minutes.", output].filter(Boolean).join("\n") : output,
+      };
+    }
+  } finally {
+    if (previousSkip === undefined) delete process.env[ENV_SKIP_VERSION_CHECK];
+    else process.env[ENV_SKIP_VERSION_CHECK] = previousSkip;
+
+    if (previousInternalSkip === undefined) delete process.env[ENV_INTERNAL_SKIP];
+    else process.env[ENV_INTERNAL_SKIP] = previousInternalSkip;
+  }
 }
 
 export default function (pi: ExtensionAPI) {
-  const suppressNativeCheck = hasNativeSelfUpdate() && !userSkippedVersionCheck;
+  // Take over pi's built-in version notice with our interactive prompt,
+  // unless the user disabled version checks themselves.
+  const suppressNativeCheck = !userSkippedVersionCheck;
   if (suppressNativeCheck) {
     process.env[ENV_SKIP_VERSION_CHECK] = "1";
     process.env[ENV_INTERNAL_SKIP] = "1";
@@ -197,36 +259,33 @@ export default function (pi: ExtensionAPI) {
   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";
-  }
+  // Consume the one-shot suppression from a post-update restart. Deleting it
+  // keeps it from propagating into any further restarts from this session.
+  const suppressStartupCheck = isEnvSet(ENV_SUPPRESS_STARTUP_CHECK);
+  delete process.env[ENV_SUPPRESS_STARTUP_CHECK];
 
   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] : ["--no-session"];
+    const cmd = currentPiCommand(restartArgs);
     const env = { ...process.env };
     if (suppressNativeCheck) {
       delete env[ENV_SKIP_VERSION_CHECK];
       delete env[ENV_INTERNAL_SKIP];
     }
+    // The user just acted on an update prompt; don't greet them with another.
+    env[ENV_SUPPRESS_STARTUP_CHECK] = "1";
 
     return ctx.ui.custom<boolean>((tui, _theme, _kb, done) => {
       tui.stop();
-      const result = spawnSync(piBinary, restartArgs, {
+      const result = spawnSync(cmd.program, cmd.args, {
         cwd: ctx.cwd,
         env,
         stdio: "inherit",
-        shell: process.platform === "win32",
         windowsHide: false,
       });
       tui.start();
@@ -236,40 +295,37 @@ export default function (pi: ExtensionAPI) {
     });
   }
 
-  async function doInstall(
-    ctx: ExtensionContext,
-    latest: string,
-    cmd: InstallCommand,
-  ) {
+  async function reloadExtensions(ctx: ExtensionContext) {
+    // Command contexts (/update) can hot-reload in place — the best path.
+    const maybeReload = (ctx as { reload?: () => Promise<void> }).reload;
+    if (typeof maybeReload === "function") {
+      ctx.ui.notify("Extensions updated. Reloading...", "info");
+      await maybeReload.call(ctx);
+      return;
+    }
+    // Event contexts (startup prompt) can't reload programmatically.
+    // Restart into the same session instead — at startup this is cheap
+    // and the user already consented by choosing "Update now".
+    if (canAutoRestart(ctx)) {
+      const ok = await restartPi(ctx);
+      if (ok) {
+        ctx.shutdown();
+        return;
+      }
+    }
+    ctx.ui.notify("Extensions updated. Run /reload to load them.", "info");
+  }
+
+  async function doInstall(ctx: ExtensionContext, target: UpdateTarget, piLatest?: string) {
+    const command = UPDATE_COMMANDS[target];
     const success = await ctx.ui.custom<boolean>((tui, theme, _kb, done) => {
-      const loader = new BorderedLoader(tui, theme, `Running ${cmd.display}...`);
+      const loader = new BorderedLoader(tui, theme, `Running ${command.display}...`);
       loader.onAbort = () => done(false);
 
-      const runUpdateCommand = async () => {
-        if (suppressNativeCheck && cmd.program === "pi") {
-          delete process.env[ENV_SKIP_VERSION_CHECK];
-          delete process.env[ENV_INTERNAL_SKIP];
-          try {
-            return await pi.exec(cmd.program, cmd.args, { timeout: 120_000 });
-          } finally {
-            process.env[ENV_SKIP_VERSION_CHECK] = "1";
-            process.env[ENV_INTERNAL_SKIP] = "1";
-          }
-        }
-        return pi.exec(cmd.program, cmd.args, { timeout: 120_000 });
-      };
-
-      runUpdateCommand()
-        .then((result) => {
-          if (result.code !== 0) {
-            const output = [result.stderr, result.stdout]
-              .filter(Boolean)
-              .join("\n")
-              .trim();
-            ctx.ui.notify(
-              `Update failed (exit ${result.code})${output ? `: ${output}` : ""}`,
-              "error",
-            );
+      runNativeUpdate(pi, target)
+        .then((failure) => {
+          if (failure) {
+            ctx.ui.notify(formatInstallFailure(failure, command.display), "error");
             done(false);
           } else {
             done(true);
@@ -288,6 +344,12 @@ export default function (pi: ExtensionAPI) {
 
     if (!success) return;
 
+    if (target === "extensions") {
+      await reloadExtensions(ctx);
+      return;
+    }
+
+    const latest = piLatest ?? "latest";
     const restartTip = ctx.sessionManager.getSessionFile()
       ? "Tip: run `pi -c` to continue this session."
       : "Tip: run `pi --no-session` to continue without a saved session.";
@@ -300,13 +362,8 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    const restart = await ctx.ui.confirm(
-      `Updated to ${latest}!`,
-      "Restart now?",
-    );
-
-    if (!restart) return;
-
+    // No confirmation: choosing the update option was the consent, and the
+    // restart relaunches straight into the current session.
     const ok = await restartPi(ctx);
     if (ok) {
       ctx.shutdown();
@@ -319,20 +376,55 @@ export default function (pi: ExtensionAPI) {
     );
   }
 
-  async function showUpdatePrompt(ctx: ExtensionContext, latest: string) {
-    const cmd = getInstallCommand(latest);
-    const choice = await ctx.ui.select(`Update ${VERSION} → ${latest}`, [
-      `Update now (${fmtCmd(cmd)})`,
-      "Skip",
-      "Skip this version",
-    ]);
-
-    if (!choice || choice === "Skip") return;
-    if (choice === "Skip this version") {
-      dismissVersion(latest);
+  async function showUpdatePrompt(ctx: ExtensionContext, offer: UpdateOffer) {
+    const { piLatest, extensions } = offer;
+    const extList = extensions.join(", ");
+
+    if (piLatest && extensions.length > 0) {
+      const updateAll = "Update all";
+      const updatePi = "Update pi only";
+      const updateExtensions = "Update extensions only";
+      // No "Ignore pi X" here: dismissing a version while also deciding about
+      // extensions is ambiguous. Version dismissal lives in the pi-only prompt.
+      const choice = await ctx.ui.select(
+        `Update pi ${VERSION} → ${piLatest} · extensions: ${extList}`,
+        [updateAll, "Skip", updatePi, updateExtensions],
+      );
+
+      if (!choice || choice === "Skip") return;
+      if (choice === updateAll) return doInstall(ctx, "all", piLatest);
+      if (choice === updatePi) return doInstall(ctx, "self", piLatest);
+      if (choice === updateExtensions) return doInstall(ctx, "extensions");
       return;
     }
-    await doInstall(ctx, latest, cmd);
+
+    if (piLatest) {
+      const updateAction = "Update now";
+      const ignorePiVersion = `Ignore ${piLatest}`;
+      const choice = await ctx.ui.select(`Update ${VERSION} → ${piLatest}`, [
+        updateAction,
+        "Skip",
+        ignorePiVersion,
+      ]);
+
+      if (!choice || choice === "Skip") return;
+      if (choice === ignorePiVersion) {
+        dismissVersion(piLatest);
+        return;
+      }
+      if (choice !== updateAction) return;
+      await doInstall(ctx, "self", piLatest);
+      return;
+    }
+
+    if (extensions.length > 0) {
+      const updateAction = "Update now";
+      const choice = await ctx.ui.select(`Extension updates available: ${extList}`, [
+        updateAction,
+        "Skip",
+      ]);
+      if (choice === updateAction) await doInstall(ctx, "extensions");
+    }
   }
 
   function canAutoPromptVersion(latest: string): boolean {
@@ -342,15 +434,21 @@ export default function (pi: ExtensionAPI) {
     return true;
   }
 
-  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: string) {
+  async function maybeShowAutoPrompt(
+    ctx: ExtensionContext,
+    latest: string | undefined,
+    extensions: string[],
+  ) {
     if (!ctx.hasUI) return;
     if (promptOpen) return;
-    if (!canAutoPromptVersion(latest)) return;
+
+    const piLatest = latest && canAutoPromptVersion(latest) ? latest : undefined;
+    if (!piLatest && extensions.length === 0) return;
 
     promptOpen = true;
-    promptedVersions.add(latest);
+    if (piLatest) promptedVersions.add(piLatest);
     try {
-      await showUpdatePrompt(ctx, latest);
+      await showUpdatePrompt(ctx, { piLatest, extensions });
     } finally {
       promptOpen = false;
     }
@@ -359,42 +457,46 @@ export default function (pi: ExtensionAPI) {
   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);
+    // Wait for both checks and show a single consolidated prompt. Startup is
+    // never blocked; the prompt simply appears when the checks resolve.
+    void Promise.all([
+      refreshLatestVersionInCache().catch(() => undefined),
+      checkForExtensionUpdates(ctx.cwd).catch(() => [] as string[]),
+    ])
+      .then(([latest, extensions]) => {
+        // Fall back to a previously cached pi version if the live fetch failed.
+        void maybeShowAutoPrompt(ctx, latest ?? getCachedUpgradeVersion(), extensions);
       })
       .catch(() => {});
   }
 
   pi.on("session_start", async (event, ctx) => {
     if (event.reason === "reload" || event.reason === "fork") return;
+    // One-shot suppression applies only to the startup right after a
+    // post-update restart, never to later new/resume session starts.
+    if (suppressStartupCheck && event.reason === "startup") return;
     runAutoChecks(ctx);
   });
 
   pi.registerCommand("update", {
-    description: "Check for pi updates and install via native updater when available",
+    description: "Check for pi updates and install with pi's native updater",
     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 updateAction = "Update now";
         const choice = await ctx.ui.select(`Update ${VERSION} → ${fakeLatest}`, [
-          `Update now (${fmtCmd(cmd)})`,
+          updateAction,
           "Skip",
-          "Skip this version",
+          `Ignore ${fakeLatest}`,
         ]);
-        if (!choice || choice === "Skip" || choice === "Skip this version") return;
+        if (choice !== updateAction) return;
 
         await ctx.ui.custom<void>((tui, theme, _kb, done) => {
-          const loader = new BorderedLoader(tui, theme, `Running ${cmd.display}...`);
+          const loader = new BorderedLoader(tui, theme, `Running ${UPDATE_COMMANDS.self.display}...`);
           loader.onAbort = () => done();
           setTimeout(() => done(), 1500);
           return loader;
@@ -405,9 +507,6 @@ export default function (pi: ExtensionAPI) {
           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");
@@ -422,35 +521,45 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      const latest = await ctx.ui.custom<string | null>(
-        (tui, theme, _kb, done) => {
-          const loader = new BorderedLoader(
-            tui,
-            theme,
-            "Checking for updates...",
-          );
-          loader.onAbort = () => done(null);
-          fetchLatestVersion()
-            .then((v) => done(v ?? null))
-            .catch(() => done(null));
-          return loader;
-        },
-      );
+      const result = await ctx.ui.custom<{
+        latest: string | undefined;
+        extensions: string[];
+      } | null>((tui, theme, _kb, done) => {
+        const loader = new BorderedLoader(
+          tui,
+          theme,
+          "Checking for updates...",
+        );
+        loader.onAbort = () => done(null);
+        Promise.all([
+          fetchLatestVersion().catch(() => undefined),
+          checkForExtensionUpdates(ctx.cwd).catch(() => [] as string[]),
+        ])
+          .then(([latest, extensions]) => done({ latest, extensions }))
+          .catch(() => done(null));
+        return loader;
+      });
 
-      if (!latest) {
+      if (!result || (!result.latest && result.extensions.length === 0)) {
         ctx.ui.notify("Could not reach Pi update service.", "error");
         return;
       }
 
-      saveLatestToCache(latest);
+      const { latest, extensions } = result;
+      if (latest) saveLatestToCache(latest);
+
+      const piLatest = latest && isNewer(latest, VERSION) ? latest : undefined;
 
-      if (!isNewer(latest, VERSION)) {
-        ctx.ui.notify(`Already on latest version (${VERSION}).`, "info");
+      if (!piLatest && extensions.length === 0) {
+        ctx.ui.notify(
+          `Already on latest version (${VERSION}). Extensions are up to date.`,
+          "info",
+        );
         return;
       }
 
-      promptedVersions.add(latest);
-      await showUpdatePrompt(ctx, latest);
+      if (piLatest) promptedVersions.add(piLatest);
+      await showUpdatePrompt(ctx, { piLatest, extensions });
     },
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-updater",
-  "version": "0.3.2",
-  "description": "Codex-style auto-updater for pi. Checks for new versions on startup and prompts to install.",
+  "version": "0.4.0",
+  "description": "Codex-style auto-updater for pi. Checks pi and extension packages on startup and prompts to install updates.",
   "type": "module",
   "license": "MIT",
   "author": "Toms clanker",
@@ -26,10 +26,15 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.65.0",
+    "@earendil-works/pi-coding-agent": "^0.74.1",
     "@types/node": "^25.3.2",
     "typescript": "^5.9.3"
   }