pi-updater 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -1,13 +1,29 @@
 # Changelog
 
+## Unreleased
+
+## 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.
+- Use pi's `https://pi.dev/api/latest-version` update endpoint with a `pi/<version>` user agent.
+- Keep pi-updater's interactive startup prompt on pi 0.70.3+ while avoiding pi's duplicate built-in version notice.
+
 ## 0.3.1 - 2026-04-04
 
 - Compatibility with pi 0.65+: use `session_start` instead of legacy `session_switch` for automatic checks. See [pi-mono v0.65.0](https://github.com/badlogic/pi-mono/releases/tag/v0.65.0).
 - Store cache and dismissed-version state in pi's configured agent directory.
 - Preserve `--no-session` mode when restarting after an update and show the correct manual restart hint.
 
-## Unreleased
-
 ## 0.3.0 - 2026-03-23
 
 - Auto-restart pi after a successful update. Asks to restart, then seamlessly relaunches on the current session.

package/README.md

@@ -5,29 +5,27 @@ A lightweight, Codex-style auto-updater for pi with fast, cache-first startup ch
 - 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.
+> **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
 
-**On startup:** if a newer version is available, shows a prompt:
+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.
 
-**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).
+**`/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.
 
 ## How version checks work
 
 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.
+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.
 

package/index.ts

@@ -1,128 +1,387 @@
 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 { spawnSync } from "node:child_process";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync, realpathSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 
-const PACKAGE_NAME = "@mariozechner/pi-coding-agent";
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const CACHE_FILE = join(getAgentDir(), "update-cache.json");
+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 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;
+}
 
 interface VersionCache {
   latestVersion: string;
+  latestPackageName?: string;
   dismissedVersion?: string;
+  dismissedPackageName?: string;
   checkedAt?: string;
 }
 
-function readCache(): VersionCache | undefined {
+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> {
+  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);
+    }
+  } 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(CACHE_FILE, "utf-8"));
+    return JSON.parse(readFileSync(cacheFile, "utf-8"));
   } catch {
     return undefined;
   }
 }
 
-function writeCache(cache: VersionCache) {
+function writeCache(cacheFile: string, cache: VersionCache) {
   try {
-    mkdirSync(dirname(CACHE_FILE), { recursive: true });
-    writeFileSync(CACHE_FILE, JSON.stringify(cache) + "\n");
+    mkdirSync(dirname(cacheFile), { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify(cache) + "\n");
   } catch {}
 }
 
-function parseVersion(v: string): [number, number, number] | undefined {
-  const parts = v.trim().split(".");
-  if (parts.length !== 3) return undefined;
-  const nums = parts.map(Number);
-  if (nums.some(isNaN)) return undefined;
-  return nums as [number, number, number];
+interface ParsedVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease?: string;
+}
+
+function parseVersion(version: string): ParsedVersion | undefined {
+  const match = version
+    .trim()
+    .match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/);
+  if (!match) return undefined;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4],
+  };
+}
+
+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 l = parseVersion(latest);
-  const c = parseVersion(current);
-  if (!l || !c) return false;
-  if (l[0] !== c[0]) return l[0] > c[0];
-  if (l[1] !== c[1]) return l[1] > c[1];
-  return l[2] > c[2];
+function isAtLeast(version: string, minimum: string): boolean {
+  const comparison = compareVersions(version, minimum);
+  return comparison !== undefined && comparison >= 0;
 }
 
 function isEnvSet(name: string): boolean {
   return Boolean(process.env[name]);
 }
 
+const userSkippedVersionCheck =
+  isEnvSet(ENV_SKIP_VERSION_CHECK) && !isEnvSet(ENV_INTERNAL_SKIP);
+
 function shouldSkipAutoChecks(): boolean {
-  return isEnvSet(ENV_SKIP_VERSION_CHECK) || isEnvSet(ENV_OFFLINE);
+  return userSkippedVersionCheck || isEnvSet(ENV_OFFLINE);
 }
 
 function isOffline(): boolean {
   return isEnvSet(ENV_OFFLINE);
 }
 
-function saveLatestToCache(latest: string) {
-  const prev = readCache();
-  writeCache({
-    latestVersion: latest,
+function piUserAgent(): string {
+  const runtime = process.versions.bun
+    ? `bun/${process.versions.bun}`
+    : `node/${process.version}`;
+  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 fetchLatestVersion(): Promise<string | undefined> {
+async function fetchLatestRelease(): Promise<LatestRelease | undefined> {
   try {
-    const res = await fetch(REGISTRY_URL, {
+    const res = await fetch(LATEST_VERSION_URL, {
+      headers: {
+        "User-Agent": piUserAgent(),
+        accept: "application/json",
+      },
       signal: AbortSignal.timeout(10_000),
     });
     if (!res.ok) return undefined;
-    return ((await res.json()) as { version?: string }).version;
+    const data = (await res.json()) as { version?: string; packageName?: 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 };
   } catch {
     return undefined;
   }
 }
 
 /** Returns a cached upgrade if available and not dismissed. */
-function getCachedUpgradeVersion(): string | undefined {
-  const cache = readCache();
+function getCachedUpgradeRelease(
+  cacheFile: string,
+  currentPackageName: string,
+): LatestRelease | undefined {
+  const cache = readCache(cacheFile);
   if (!cache) return undefined;
-  if (!isNewer(cache.latestVersion, VERSION)) return undefined;
-  if (cache.dismissedVersion === cache.latestVersion) return undefined;
-  return cache.latestVersion;
+  const release = {
+    version: cache.latestVersion,
+    packageName: cache.latestPackageName,
+  };
+  if (!isUpdateAvailable(release, currentPackageName)) return undefined;
+  if (isDismissed(cache, release, currentPackageName)) return undefined;
+  return release;
 }
 
-/** Fetch latest from npm and refresh cache. */
-async function refreshLatestVersionInCache(): Promise<string | undefined> {
-  const latest = await fetchLatestVersion();
+/** Fetch latest from Pi's update endpoint and refresh cache. */
+async function refreshLatestReleaseInCache(cacheFile: string): Promise<LatestRelease | undefined> {
+  const latest = await fetchLatestRelease();
   if (!latest) return undefined;
-  saveLatestToCache(latest);
+  saveLatestToCache(cacheFile, latest);
   return latest;
 }
 
-function dismissVersion(version: string) {
-  const cache = readCache();
-  writeCache({
-    latestVersion: cache?.latestVersion ?? version,
-    dismissedVersion: version,
+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),
     checkedAt: cache?.checkedAt,
   });
 }
 
-function getInstallCommand(version: string): { program: string; args: string[] } {
+interface InstallStep {
+  program: string;
+  args: string[];
+  display: string;
+}
+
+interface InstallCommand {
+  steps: InstallStep[];
+  display: string;
+  targetVersion: string;
+  targetPackageName: string;
+}
+
+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: ["install", "-g", `${PACKAGE_NAME}@${version}`],
+    args: stepArgs,
+    display: ["npm", ...stepArgs].join(" "),
   };
 }
 
-function fmtCmd(cmd: { program: string; args: string[] }): string {
-  return `${cmd.program} ${cmd.args.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,
+  };
 }
 
-export default function (pi: ExtensionAPI) {
+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(
+  pi: ExtensionAPI,
+  cmd: InstallCommand,
+): 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) {
+      return {
+        step,
+        code: result.code,
+        output: [result.stderr, result.stdout].filter(Boolean).join("\n").trim(),
+      };
+    }
+  }
+}
+
+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;
+  if (suppressNativeCheck) {
+    process.env[ENV_SKIP_VERSION_CHECK] = "1";
+    process.env[ENV_INTERNAL_SKIP] = "1";
+  }
+
   let promptOpen = false;
   const promptedVersions = new Set<string>();
   let liveCheckStarted = false;
@@ -144,12 +403,17 @@ export default function (pi: ExtensionAPI) {
     const piBinary = await findPiBinary();
     const sessionFile = ctx.sessionManager.getSessionFile();
     const restartArgs = sessionFile ? ["--session", sessionFile] : ["--no-session"];
+    const env = { ...process.env };
+    if (suppressNativeCheck) {
+      delete env[ENV_SKIP_VERSION_CHECK];
+      delete env[ENV_INTERNAL_SKIP];
+    }
 
     return ctx.ui.custom<boolean>((tui, _theme, _kb, done) => {
       tui.stop();
       const result = spawnSync(piBinary, restartArgs, {
         cwd: ctx.cwd,
-        env: process.env,
+        env,
         stdio: "inherit",
         shell: process.platform === "win32",
         windowsHide: false,
@@ -164,25 +428,28 @@ export default function (pi: ExtensionAPI) {
   async function doInstall(
     ctx: ExtensionContext,
     latest: string,
-    cmd: { program: string; args: string[] },
+    cmd: InstallCommand,
   ) {
     const success = await ctx.ui.custom<boolean>((tui, theme, _kb, done) => {
-      const loader = new BorderedLoader(tui, theme, `Installing ${latest}...`);
+      const loader = new BorderedLoader(tui, theme, `Running ${cmd.display}...`);
       loader.onAbort = () => done(false);
 
-      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",
-            );
+      runInstallCommand(pi, cmd)
+        .then((failure) => {
+          if (failure) {
+            ctx.ui.notify(formatInstallFailure(failure, cmd), "error");
             done(false);
           } else {
             done(true);
           }
         })
-        .catch(() => done(false));
+        .catch((error) => {
+          ctx.ui.notify(
+            `Update failed: ${error instanceof Error ? error.message : String(error)}`,
+            "error",
+          );
+          done(false);
+        });
 
       return loader;
     });
@@ -220,36 +487,39 @@ 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)})`,
+  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") {
-      dismissVersion(latest);
+      dismissRelease(cacheFile, latest, currentPackageName);
       return;
     }
-    await doInstall(ctx, latest, cmd);
+    await doInstall(ctx, targetLabel, cmd);
   }
 
-  function canAutoPromptVersion(latest: string): boolean {
-    if (!isNewer(latest, VERSION)) return false;
-    if (promptedVersions.has(latest)) return false;
-    if (readCache()?.dismissedVersion === latest) return false;
+  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;
     return true;
   }
 
-  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: string) {
+  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: LatestRelease) {
     if (!ctx.hasUI) return;
     if (promptOpen) return;
     if (!canAutoPromptVersion(latest)) return;
 
     promptOpen = true;
-    promptedVersions.add(latest);
+    promptedVersions.add(releaseKey(latest, currentPackageName));
     try {
       await showUpdatePrompt(ctx, latest);
     } finally {
@@ -261,13 +531,13 @@ export default function (pi: ExtensionAPI) {
     if (!ctx.hasUI) return;
     if (shouldSkipAutoChecks()) return;
 
-    const cached = getCachedUpgradeVersion();
+    const cached = getCachedUpgradeRelease(cacheFile, currentPackageName);
     if (cached) void maybeShowAutoPrompt(ctx, cached);
 
     if (liveCheckStarted) return;
     liveCheckStarted = true;
 
-    void refreshLatestVersionInCache()
+    void refreshLatestReleaseInCache(cacheFile)
       .then((latest) => {
         if (!latest) return;
         void maybeShowAutoPrompt(ctx, latest);
@@ -281,21 +551,21 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerCommand("update", {
-    description: "Check for pi updates and install",
+    description: "Check for pi updates and install with npm",
     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)})`,
+        const cmd = getInstallCommand({ version: fakeLatest }, currentPackageName);
+        const choice = await ctx.ui.select(`Update ${currentPackageName}@${VERSION} → ${cmd.targetPackageName}@${fakeLatest}`, [
+          `Update now (${cmd.display})`,
           "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}...`);
+          const loader = new BorderedLoader(tui, theme, `Running ${cmd.display}...`);
           loader.onAbort = () => done();
           setTimeout(() => done(), 1500);
           return loader;
@@ -323,7 +593,7 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      const latest = await ctx.ui.custom<string | null>(
+      const latest = await ctx.ui.custom<LatestRelease | null>(
         (tui, theme, _kb, done) => {
           const loader = new BorderedLoader(
             tui,
@@ -331,7 +601,7 @@ export default function (pi: ExtensionAPI) {
             "Checking for updates...",
           );
           loader.onAbort = () => done(null);
-          fetchLatestVersion()
+          fetchLatestRelease()
             .then((v) => done(v ?? null))
             .catch(() => done(null));
           return loader;
@@ -339,18 +609,18 @@ export default function (pi: ExtensionAPI) {
       );
 
       if (!latest) {
-        ctx.ui.notify("Could not reach npm registry.", "error");
+        ctx.ui.notify("Could not reach Pi update service.", "error");
         return;
       }
 
-      saveLatestToCache(latest);
+      saveLatestToCache(cacheFile, latest);
 
-      if (!isNewer(latest, VERSION)) {
-        ctx.ui.notify(`Already on latest version (${VERSION}).`, "info");
+      if (!isUpdateAvailable(latest, currentPackageName)) {
+        ctx.ui.notify(`Already on latest version (${currentPackageName}@${VERSION}).`, "info");
         return;
       }
 
-      promptedVersions.add(latest);
+      promptedVersions.add(releaseKey(latest, currentPackageName));
       await showUpdatePrompt(ctx, latest);
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-updater",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Codex-style auto-updater for pi. Checks for new versions on startup and prompts to install.",
   "type": "module",
   "license": "MIT",
@@ -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"
   }