portable-agent-layer 0.6.2 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/index.ts

@@ -122,6 +122,18 @@ async function session(sessionArgs: string[]) {
     // Silently ignore summary errors
   }
 
+  // Check for updates and display notice
+  try {
+    const { checkForUpdate, getUpdateNotice } = await import(
+      "../hooks/handlers/update-check"
+    );
+    await checkForUpdate();
+    const notice = getUpdateNotice();
+    if (notice) console.log(`\n${notice}`);
+  } catch {
+    // Non-critical
+  }
+
   process.exit(exitCode);
 }
 

package/src/hooks/handlers/update-check.ts

@@ -0,0 +1,189 @@
+/**
+ * Update checker — detects if a newer version of PAL is available.
+ *
+ * Repo mode (.palroot exists): git fetch + compare HEAD vs origin/main
+ * Package mode: fetch npm registry for latest version vs installed
+ *
+ * Caches result in state/update-available.json. Checked at most once per hour.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { logDebug } from "../lib/log";
+import { ensureDir, palPkg, paths } from "../lib/paths";
+
+interface UpdateCache {
+  checkedAt: string;
+  available: boolean;
+  current: string;
+  latest: string;
+  mode: "repo" | "package";
+}
+
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+function cachePath(): string {
+  return resolve(ensureDir(paths.state()), "update-available.json");
+}
+
+function readCache(): UpdateCache | null {
+  try {
+    const fp = cachePath();
+    if (!existsSync(fp)) return null;
+    const cache = JSON.parse(readFileSync(fp, "utf-8")) as UpdateCache;
+    if (Date.now() - new Date(cache.checkedAt).getTime() < CACHE_TTL_MS) return cache;
+    return null; // expired
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(cache: UpdateCache): void {
+  try {
+    writeFileSync(cachePath(), JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+    /* non-critical */
+  }
+}
+
+function isRepoMode(): boolean {
+  return existsSync(resolve(palPkg(), ".palroot"));
+}
+
+function getInstalledVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(palPkg(), "package.json"), "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+async function checkRepo(): Promise<UpdateCache> {
+  const repoDir = palPkg();
+  const current = getInstalledVersion();
+
+  try {
+    const fetch = Bun.spawn(["git", "fetch", "--quiet"], {
+      cwd: repoDir,
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    await fetch.exited;
+
+    const local = Bun.spawn(["git", "rev-parse", "HEAD"], {
+      cwd: repoDir,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const localHash = (await new Response(local.stdout).text()).trim();
+
+    const remote = Bun.spawn(["git", "rev-parse", "origin/main"], {
+      cwd: repoDir,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const remoteHash = (await new Response(remote.stdout).text()).trim();
+
+    const available = localHash !== remoteHash && remoteHash.length > 0;
+
+    // Get remote version from package.json on origin/main
+    let latest = current;
+    if (available) {
+      try {
+        const show = Bun.spawn(["git", "show", "origin/main:package.json"], {
+          cwd: repoDir,
+          stdout: "pipe",
+          stderr: "ignore",
+        });
+        const remotePkg = JSON.parse(await new Response(show.stdout).text());
+        latest = remotePkg.version || current;
+      } catch {
+        latest = `${remoteHash.slice(0, 7)} (ahead)`;
+      }
+    }
+
+    return {
+      checkedAt: new Date().toISOString(),
+      available,
+      current,
+      latest,
+      mode: "repo",
+    };
+  } catch {
+    return {
+      checkedAt: new Date().toISOString(),
+      available: false,
+      current,
+      latest: current,
+      mode: "repo",
+    };
+  }
+}
+
+async function checkNpm(): Promise<UpdateCache> {
+  const current = getInstalledVersion();
+
+  try {
+    const response = await fetch(
+      "https://registry.npmjs.org/portable-agent-layer/latest",
+      { signal: AbortSignal.timeout(5000) }
+    );
+
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = (await response.json()) as { version?: string };
+    const latest = data.version || current;
+
+    return {
+      checkedAt: new Date().toISOString(),
+      available: latest !== current,
+      current,
+      latest,
+      mode: "package",
+    };
+  } catch {
+    return {
+      checkedAt: new Date().toISOString(),
+      available: false,
+      current,
+      latest: current,
+      mode: "package",
+    };
+  }
+}
+
+/** Run update check on Stop (non-blocking). Caches result for greeting. */
+export async function checkForUpdate(): Promise<void> {
+  const cached = readCache();
+  if (cached) {
+    logDebug("update-check", "Using cached result");
+    return;
+  }
+
+  const result = isRepoMode() ? await checkRepo() : await checkNpm();
+  writeCache(result);
+
+  if (result.available) {
+    logDebug(
+      "update-check",
+      `Update available: ${result.current} → ${result.latest} (${result.mode})`
+    );
+  }
+}
+
+/** Read cached update status for greeting display. Returns null if no update. */
+export function getUpdateNotice(): string | null {
+  try {
+    const fp = cachePath();
+    if (!existsSync(fp)) return null;
+    const cache = JSON.parse(readFileSync(fp, "utf-8")) as UpdateCache;
+    if (!cache.available) return null;
+
+    if (cache.mode === "repo") {
+      return `📦 Update available: ${cache.current} → ${cache.latest} (git pull)`;
+    }
+    return `📦 Update available: ${cache.current} → ${cache.latest} (bun update -g portable-agent-layer)`;
+  } catch {
+    return null;
+  }
+}

package/src/hooks/lib/security.ts

@@ -30,6 +30,7 @@ export const HOOK_MANAGED_FILES = [
   "pending-failure.json",
   "token-usage.jsonl",
   "graduated.json",
+  "update-available.json",
 ];
 
 /** Hook-managed directories — AI must not write to or delete from these */