pi-updater 0.3.3 → 0.4.0

package/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 
-## Unreleased
+## 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
 

package/README.md

@@ -1,70 +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:** pi-updater installs the exact package/version returned by pi's update service with npm. This handles pi package-name migrations and avoids stale native self-update behavior while still keeping the interactive prompt/restart flow.
-
 <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
-
-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
-
-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.
+## Why does this exist?
 
-**`/update`:** manually check for updates (always fetches fresh from pi's update service, unless `PI_OFFLINE` is set). It installs the exact npm package/version advertised by pi's update service and respects npm engine requirements, so upgrade Node.js first if the new pi release requires it.
+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.
 
-## How version checks work
+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.
 
-pi-updater uses a cache-first approach to keep startup fast:
+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.
 
-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.
-
-## Install
+## Installation
 
 ```bash
 pi install npm:pi-updater
 ```
 
-Or from git:
-
-```bash
-pi install git:github.com/tonze/pi-updater
-```
+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`.
 
 ## Usage
 
-Use `/update` inside pi to manually check for updates and install them.
+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).
 
-Cache and dismissed-version state are stored in pi's configured agent directory and respect `PI_CODING_AGENT_DIR`.
+If only pi is outdated:
 
-## Environment flags
+- **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
 
-Disable automatic version checks:
+If both pi and extensions are outdated, a combined prompt appears:
 
-```bash
-export PI_SKIP_VERSION_CHECK=1
-```
+- **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
+
+Version dismissal ("Ignore") is only offered in the pi-only prompt; a
+dismissed pi version degrades the combined prompt to extensions-only.
+
+If only extensions are outdated, you're offered `pi update --extensions`.
 
-Or run in offline mode (also disables automatic checks):
+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.
+
+You can also check manually at any time with `/update`.
+
+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.
+
+`/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

@@ -2,117 +2,53 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { VERSION, BorderedLoader, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { spawnSync } from "node:child_process";
-import { readFileSync, realpathSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 
-const PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-const LEGACY_PACKAGE_NAME = "@mariozechner/pi-coding-agent";
 const LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
-const NATIVE_VERSION_NOTICE_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";
-
-interface LatestRelease {
-  version: string;
-  packageName?: string;
-}
+// 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;
-  latestPackageName?: string;
   dismissedVersion?: string;
-  dismissedPackageName?: string;
   checkedAt?: string;
 }
 
-type BorderedLoaderConstructor = new (...args: any[]) => any;
-
-interface PiRuntime {
-  VERSION: string;
-  BorderedLoader: BorderedLoaderConstructor;
-  getAgentDir: () => string;
-  packageName: string;
-}
-
-let VERSION = "0.0.0";
-let BorderedLoader: BorderedLoaderConstructor;
-let getAgentDir: () => string;
-
-function packageNameFromNodeModulesPath(path: string): string | undefined {
-  const normalized = path.replace(/\\/g, "/");
-  const marker = "/node_modules/";
-  const index = normalized.lastIndexOf(marker);
-  if (index === -1) return undefined;
-
-  const parts = normalized.slice(index + marker.length).split("/");
-  if (!parts[0]) return undefined;
-  if (parts[0].startsWith("@")) {
-    if (!parts[1]) return undefined;
-    return `${parts[0]}/${parts[1]}`;
-  }
-  return parts[0];
-}
-
-async function findOwningPiPackageName(pi: ExtensionAPI): Promise<string | undefined> {
+function readCache(): VersionCache | undefined {
   try {
-    const cmd = process.platform === "win32" ? "where" : "which";
-    const result = await pi.exec(cmd, ["pi"]);
-    const binary = result.code === 0 ? result.stdout?.trim().split(/\r?\n/)[0] : undefined;
-    if (!binary) return undefined;
-
-    try {
-      return packageNameFromNodeModulesPath(realpathSync(binary));
-    } catch {
-      return packageNameFromNodeModulesPath(binary);
-    }
+    return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
   } catch {
     return undefined;
   }
 }
 
-async function loadPiRuntime(preferredPackageName?: string): Promise<PiRuntime> {
-  const packageNames = [
-    preferredPackageName,
-    PACKAGE_NAME,
-    LEGACY_PACKAGE_NAME,
-  ].filter((packageName): packageName is string => !!packageName);
-
-  for (const packageName of new Set(packageNames)) {
-    try {
-      const runtime = await import(packageName);
-      if (
-        typeof runtime.VERSION === "string" &&
-        typeof runtime.BorderedLoader === "function" &&
-        typeof runtime.getAgentDir === "function"
-      ) {
-        return {
-          VERSION: runtime.VERSION,
-          BorderedLoader: runtime.BorderedLoader,
-          getAgentDir: runtime.getAgentDir,
-          packageName,
-        };
-      }
-    } catch {}
-  }
-
-  throw new Error(`Could not load ${PACKAGE_NAME} or ${LEGACY_PACKAGE_NAME}`);
-}
-
-function readCache(cacheFile: string): VersionCache | undefined {
-  try {
-    return JSON.parse(readFileSync(cacheFile, "utf-8"));
-  } catch {
-    return undefined;
-  }
-}
-
-function writeCache(cacheFile: string, cache: VersionCache) {
+function writeCache(cache: VersionCache) {
   try {
-    mkdirSync(dirname(cacheFile), { recursive: true });
-    writeFileSync(cacheFile, JSON.stringify(cache) + "\n");
+    mkdirSync(dirname(CACHE_FILE), { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(cache) + "\n");
   } catch {}
 }
 
@@ -136,22 +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 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 {
@@ -176,46 +107,7 @@ function piUserAgent(): string {
   return `pi/${VERSION} (${process.platform}; ${runtime}; ${process.arch})`;
 }
 
-function hasNativeVersionNotice(): boolean {
-  return isAtLeast(VERSION, NATIVE_VERSION_NOTICE_MIN_VERSION);
-}
-
-function targetPackageName(release: LatestRelease, currentPackageName: string): string {
-  return release.packageName ?? currentPackageName;
-}
-
-function releaseKey(release: LatestRelease, currentPackageName: string): string {
-  return `${targetPackageName(release, currentPackageName)}@${release.version}`;
-}
-
-function isUpdateAvailable(release: LatestRelease, currentPackageName: string): boolean {
-  const comparison = compareVersions(release.version, VERSION);
-  if (comparison === undefined) return false;
-  return comparison > 0 || (comparison === 0 && targetPackageName(release, currentPackageName) !== currentPackageName);
-}
-
-function isDismissed(
-  cache: VersionCache,
-  release: LatestRelease,
-  currentPackageName: string,
-): boolean {
-  if (cache.dismissedVersion !== release.version) return false;
-  if (!cache.dismissedPackageName) return !release.packageName;
-  return cache.dismissedPackageName === targetPackageName(release, currentPackageName);
-}
-
-function saveLatestToCache(cacheFile: string, latest: LatestRelease) {
-  const prev = readCache(cacheFile);
-  writeCache(cacheFile, {
-    latestVersion: latest.version,
-    latestPackageName: latest.packageName,
-    dismissedVersion: prev?.dismissedVersion,
-    dismissedPackageName: prev?.dismissedPackageName,
-    checkedAt: new Date().toISOString(),
-  });
-}
-
-async function fetchLatestRelease(): Promise<LatestRelease | undefined> {
+async function fetchLatestVersion(): Promise<string | undefined> {
   try {
     const res = await fetch(LATEST_VERSION_URL, {
       headers: {
@@ -225,158 +117,139 @@ async function fetchLatestRelease(): Promise<LatestRelease | undefined> {
       signal: AbortSignal.timeout(10_000),
     });
     if (!res.ok) return undefined;
-    const data = (await res.json()) as { version?: string; packageName?: string };
+    const data = (await res.json()) as { version?: string };
     if (typeof data.version !== "string" || !data.version.trim()) return undefined;
-    const packageName =
-      typeof data.packageName === "string" && data.packageName.trim()
-        ? data.packageName.trim()
-        : undefined;
-    return { version: data.version.trim(), packageName };
+    return data.version.trim();
   } catch {
     return undefined;
   }
 }
 
-/** Returns a cached upgrade if available and not dismissed. */
-function getCachedUpgradeRelease(
-  cacheFile: string,
-  currentPackageName: string,
-): LatestRelease | undefined {
-  const cache = readCache(cacheFile);
+/**
+ * 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;
-  const release = {
-    version: cache.latestVersion,
-    packageName: cache.latestPackageName,
-  };
-  if (!isUpdateAvailable(release, currentPackageName)) return undefined;
-  if (isDismissed(cache, release, currentPackageName)) return undefined;
-  return release;
+  if (!isNewer(cache.latestVersion, VERSION)) return undefined;
+  if (cache.dismissedVersion === cache.latestVersion) return 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 refreshLatestReleaseInCache(cacheFile: string): Promise<LatestRelease | undefined> {
-  const latest = await fetchLatestRelease();
+async function refreshLatestVersionInCache(): Promise<string | undefined> {
+  const latest = await fetchLatestVersion();
   if (!latest) return undefined;
-  saveLatestToCache(cacheFile, latest);
+  saveLatestToCache(latest);
   return latest;
 }
 
-function dismissRelease(
-  cacheFile: string,
-  release: LatestRelease,
-  currentPackageName: string,
-) {
-  const cache = readCache(cacheFile);
-  writeCache(cacheFile, {
-    latestVersion: cache?.latestVersion ?? release.version,
-    latestPackageName: cache?.latestPackageName ?? release.packageName,
-    dismissedVersion: release.version,
-    dismissedPackageName: targetPackageName(release, currentPackageName),
+function dismissVersion(version: string) {
+  const cache = readCache();
+  writeCache({
+    latestVersion: cache?.latestVersion ?? version,
+    dismissedVersion: version,
     checkedAt: cache?.checkedAt,
   });
 }
 
-interface InstallStep {
-  program: string;
-  args: string[];
-  display: string;
+function isBunFsPath(path: string): boolean {
+  return path.includes("$bunfs") || path.includes("~BUN") || path.includes("%7EBUN");
 }
 
-interface InstallCommand {
-  steps: InstallStep[];
-  display: string;
-  targetVersion: string;
-  targetPackageName: string;
+/**
+ * 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 };
 }
 
 interface InstallFailure {
-  step: InstallStep;
   code: number;
   output: string;
 }
 
-function npmInstallStep(packageSpec: string, args: string[] = []): InstallStep {
-  const stepArgs = ["install", "-g", packageSpec, ...args];
-  return {
-    program: "npm",
-    args: stepArgs,
-    display: ["npm", ...stepArgs].join(" "),
-  };
-}
-
-function getInstallCommand(
-  release: LatestRelease,
-  currentPackageName: string,
-): InstallCommand {
-  const updatePackageName = targetPackageName(release, currentPackageName);
-  const targetVersion = release.version;
-  const packageSpec = `${updatePackageName}@${targetVersion}`;
-  const packageChanged = updatePackageName !== currentPackageName;
-  const installStep = npmInstallStep(packageSpec, ["--engine-strict=true"]);
-
-  if (!packageChanged) {
-    return {
-      steps: [installStep],
-      display: installStep.display,
-      targetVersion,
-      targetPackageName: updatePackageName,
-    };
-  }
-
-  return {
-    steps: [
-      npmInstallStep(packageSpec, ["--dry-run", "--engine-strict=true"]),
-      npmInstallStep(packageSpec, ["--force"]),
-    ],
-    display: `migrate ${currentPackageName} → ${packageSpec}`,
-    targetVersion,
-    targetPackageName: updatePackageName,
-  };
+function formatInstallFailure(failure: InstallFailure, display: string): string {
+  return `Update failed while running \`${display}\` (exit ${failure.code})${failure.output ? `: ${failure.output}` : ""}`;
 }
 
-function extractRequiredNodeVersion(output: string): string | undefined {
-  return (
-    output.match(/required:\s*\{\s*node:\s*['"]([^'"]+)['"]/i)?.[1] ??
-    output.match(/Required:\s*\{[^}]*"node":"([^"]+)"/i)?.[1]
-  );
-}
-
-function formatInstallFailure(failure: InstallFailure, cmd: InstallCommand): string {
-  if (/EBADENGINE|Unsupported engine|not compatible with your version of node/i.test(failure.output)) {
-    const requiredNode = extractRequiredNodeVersion(failure.output);
-    const requirement = requiredNode ? ` Requires Node.js ${requiredNode}.` : "";
-    return `Update blocked: pi ${cmd.targetVersion} is incompatible with current Node.js ${process.version}.${requirement} Upgrade Node.js, restart pi, then run /update again.`;
-  }
-
-  return `Update failed while running \`${failure.step.display}\` (exit ${failure.code})${failure.output ? `: ${failure.output}` : ""}`;
-}
-
-async function runInstallCommand(
+async function runNativeUpdate(
   pi: ExtensionAPI,
-  cmd: InstallCommand,
+  target: UpdateTarget,
 ): Promise<InstallFailure | undefined> {
-  for (const step of cmd.steps) {
-    const result = await pi.exec(step.program, step.args, { timeout: 120_000 });
-    if (result.code !== 0) {
+  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 {
-        step,
         code: result.code,
-        output: [result.stderr, result.stdout].filter(Boolean).join("\n").trim(),
+        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 async function (pi: ExtensionAPI) {
-  const owningPackageName = await findOwningPiPackageName(pi);
-  const runtime = await loadPiRuntime(owningPackageName);
-  VERSION = runtime.VERSION;
-  BorderedLoader = runtime.BorderedLoader;
-  getAgentDir = runtime.getAgentDir;
-  const currentPackageName = owningPackageName ?? runtime.packageName;
-
-  const cacheFile = join(getAgentDir(), "update-cache.json");
-  const suppressNativeCheck = hasNativeVersionNotice() && !userSkippedVersionCheck;
+export default function (pi: ExtensionAPI) {
+  // 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";
@@ -386,36 +259,33 @@ export default async 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();
@@ -425,19 +295,37 @@ export default async 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);
 
-      runInstallCommand(pi, cmd)
+      runNativeUpdate(pi, target)
         .then((failure) => {
           if (failure) {
-            ctx.ui.notify(formatInstallFailure(failure, cmd), "error");
+            ctx.ui.notify(formatInstallFailure(failure, command.display), "error");
             done(false);
           } else {
             done(true);
@@ -456,6 +344,12 @@ export default async 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.";
@@ -468,13 +362,8 @@ export default async 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();
@@ -487,41 +376,79 @@ export default async function (pi: ExtensionAPI) {
     );
   }
 
-  async function showUpdatePrompt(ctx: ExtensionContext, latest: LatestRelease) {
-    const cmd = getInstallCommand(latest, currentPackageName);
-    const currentLabel = `${currentPackageName}@${VERSION}`;
-    const targetLabel = `${cmd.targetPackageName}@${cmd.targetVersion}`;
-    const choice = await ctx.ui.select(`Update ${currentLabel} → ${targetLabel}`, [
-      `Update now (${cmd.display})`,
-      "Skip",
-      "Skip this version",
-    ]);
-
-    if (!choice || choice === "Skip") return;
-    if (choice === "Skip this version") {
-      dismissRelease(cacheFile, latest, currentPackageName);
+  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, targetLabel, 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: LatestRelease): boolean {
-    if (!isUpdateAvailable(latest, currentPackageName)) return false;
-    if (promptedVersions.has(releaseKey(latest, currentPackageName))) return false;
-    const cache = readCache(cacheFile);
-    if (cache && isDismissed(cache, latest, currentPackageName)) return false;
+  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: LatestRelease) {
+  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(releaseKey(latest, currentPackageName));
+    if (piLatest) promptedVersions.add(piLatest);
     try {
-      await showUpdatePrompt(ctx, latest);
+      await showUpdatePrompt(ctx, { piLatest, extensions });
     } finally {
       promptOpen = false;
     }
@@ -530,42 +457,46 @@ export default async function (pi: ExtensionAPI) {
   function runAutoChecks(ctx: ExtensionContext) {
     if (!ctx.hasUI) return;
     if (shouldSkipAutoChecks()) return;
-
-    const cached = getCachedUpgradeRelease(cacheFile, currentPackageName);
-    if (cached) void maybeShowAutoPrompt(ctx, cached);
-
     if (liveCheckStarted) return;
     liveCheckStarted = true;
 
-    void refreshLatestReleaseInCache(cacheFile)
-      .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 with npm",
+    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({ version: fakeLatest }, currentPackageName);
-        const choice = await ctx.ui.select(`Update ${currentPackageName}@${VERSION} → ${cmd.targetPackageName}@${fakeLatest}`, [
-          `Update now (${cmd.display})`,
+        const updateAction = "Update now";
+        const choice = await ctx.ui.select(`Update ${VERSION} → ${fakeLatest}`, [
+          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;
@@ -576,9 +507,6 @@ export default async 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");
@@ -593,35 +521,45 @@ export default async function (pi: ExtensionAPI) {
         return;
       }
 
-      const latest = await ctx.ui.custom<LatestRelease | null>(
-        (tui, theme, _kb, done) => {
-          const loader = new BorderedLoader(
-            tui,
-            theme,
-            "Checking for updates...",
-          );
-          loader.onAbort = () => done(null);
-          fetchLatestRelease()
-            .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(cacheFile, latest);
+      const { latest, extensions } = result;
+      if (latest) saveLatestToCache(latest);
 
-      if (!isUpdateAvailable(latest, currentPackageName)) {
-        ctx.ui.notify(`Already on latest version (${currentPackageName}@${VERSION}).`, "info");
+      const piLatest = latest && isNewer(latest, VERSION) ? latest : undefined;
+
+      if (!piLatest && extensions.length === 0) {
+        ctx.ui.notify(
+          `Already on latest version (${VERSION}). Extensions are up to date.`,
+          "info",
+        );
         return;
       }
 
-      promptedVersions.add(releaseKey(latest, currentPackageName));
-      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.3",
-  "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",