@bigking67/pi-67 0.10.2 → 0.10.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.10.3]
+
+- Deduplicates real update/repair runtime backups when preserved config files
+  are unchanged from the latest same-operation backup.
+- Deduplicates direct PowerShell `scripts/pi67-update.ps1` dirty runtime-config
+  preservation backups under `~/.pi/pi67/backups/`.
+- Removes the legacy PowerShell updater path that wrote new
+  `~/.pi/agent-backups/pre-update-*` snapshots; runtime preservation now stays
+  under `~/.pi/pi67/backups/`.
+- Avoids writing a theme backup when `pi-67 themes set <name>` is already the
+  active theme.
+
 ## [0.10.2]
 
 - Reads `Manager latest` through the npm registry HTTP API instead of spawning

package/README.md

@@ -78,6 +78,9 @@ Before a real `update` or `repair`, the npm manager acquires
 `~/.pi/pi67/backups/<timestamp>-update/`. This makes the public `npx -y
 @bigking67/pi-67@latest update --repair` path safe even for in-place checkouts
 where `settings.json` is tracked but user-owned.
+If the preserved runtime files are unchanged from the latest same-operation
+backup, the manager reuses that snapshot instead of writing another timestamped
+directory.
 
 Runtime backups are first-class CLI state:
 
@@ -94,9 +97,10 @@ The restore command only restores preserved runtime files and writes a
 pre-restore backup before overwriting current local config.
 
 Legacy PowerShell `~/.pi/agent-backups/pre-update-*` directories are read-only
-known-conflict snapshots from older migration paths. They are listed only with
-`--include-legacy` and are intentionally separate from restorable runtime
-backups under `~/.pi/pi67/backups/`.
+known-conflict snapshots from older migration paths; the normal updater no
+longer writes new ones. They are listed only with `--include-legacy` and are
+intentionally separate from restorable runtime backups under
+`~/.pi/pi67/backups/`.
 
 Theme changes are explicit only:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigking67/pi-67",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Cross-platform manager CLI for the pi-67 Pi Coding Agent distribution.",
   "type": "module",
   "bin": {

package/scripts/check.mjs

@@ -370,6 +370,20 @@ function runUpdateSafetySelfTests() {
     listRuntimeBackups(ctx).some((item) => item.path === lifecycle.backupDir),
     "update lifecycle backups must be listable",
   );
+  const backupCountBeforeDedupe = listRuntimeBackups(ctx).length;
+  const duplicateLifecycle = beginUpdateLifecycle({
+    agentDir,
+    repoRoot: agentDir,
+    stateDir,
+  }, {
+    operation: "test",
+  });
+  assert(duplicateLifecycle.backupSkipped, "unchanged update lifecycle snapshots must be deduplicated");
+  duplicateLifecycle.release();
+  assert(
+    listRuntimeBackups(ctx).length === backupCountBeforeDedupe,
+    "deduplicated update lifecycle snapshots must not create new backup directories",
+  );
   assert(
     inspectRuntimeBackup(ctx, lifecycle.backupDir).fileCount >= 2,
     "update lifecycle backups must be inspectable",

package/src/commands/themes.mjs

@@ -56,6 +56,10 @@ function setTheme(ctx, argv) {
   const settingsFile = path.join(ctx.agentDir, "settings.json");
   const settings = readJsonFileIfExists(settingsFile) || {};
   const previous = settings.theme || "";
+  if (previous === name) {
+    pass(`theme already set: ${name}`);
+    return;
+  }
   settings.theme = name;
   if (ctx.dryRun || options.dryRun) {
     info(`DRY-RUN set theme ${previous || "unset"} -> ${name}`);

package/src/commands/update.mjs

@@ -50,6 +50,8 @@ export async function updateCommand(ctx, argv) {
   });
   if (!dryRun && lifecycle.backedUp.length > 0) {
     info(`Preserved runtime backup: ${lifecycle.backupDir}`);
+  } else if (!dryRun && lifecycle.backupSkipped) {
+    info(`Preserved runtime backup skipped: ${lifecycle.backupReason}`);
   }
 
   const args = isWindows()

package/src/lib/update-safety.mjs

@@ -35,14 +35,19 @@ export function beginUpdateLifecycle(ctx, options = {}) {
   acquireLock(lockPath, { operation });
   let released = false;
   try {
-    const backedUp = createRuntimeBackup(ctx, backupDir, {
+    const backup = createRuntimeBackup(ctx, backupDir, {
       operation,
       plan: options.plan,
+      dedupe: true,
+      returnResult: true,
     });
     return {
       lockPath,
-      backupDir,
-      backedUp,
+      backupDir: backup.backupDir,
+      backedUp: backup.backedUp,
+      backupSkipped: backup.skipped,
+      backupReason: backup.reason || "",
+      reusedBackupDir: backup.reusedBackupDir || "",
       release() {
         if (released) return;
         released = true;
@@ -56,34 +61,37 @@ export function beginUpdateLifecycle(ctx, options = {}) {
 }
 
 export function createRuntimeBackup(ctx, backupDir, options = {}) {
+  const operation = options.operation || "update";
+  const preserved = collectPreservedRuntimeFiles(ctx);
+  if (options.dedupe) {
+    const equivalent = findEquivalentRuntimeBackup(ctx, preserved, operation);
+    if (equivalent) {
+      const result = {
+        backupDir: equivalent.path,
+        backedUp: [],
+        skipped: true,
+        reusedBackupDir: equivalent.path,
+        reason: `same preserved runtime snapshot already exists: ${equivalent.id}`,
+      };
+      return options.returnResult ? result : result.backedUp;
+    }
+  }
+
   fs.mkdirSync(backupDir, { recursive: true, mode: 0o700 });
   const filesDir = path.join(backupDir, "files");
   fs.mkdirSync(filesDir, { recursive: true, mode: 0o700 });
 
-  const preserved = [];
-  const backedUp = [];
   for (const rel of PRESERVED_RUNTIME_FILES) {
+    const item = preserved.find((entry) => entry.path === rel);
+    if (!item?.exists) continue;
     const source = path.join(ctx.agentDir, rel);
-    if (!fs.existsSync(source)) {
-      preserved.push({
-        path: rel,
-        exists: false,
-      });
-      continue;
-    }
     const target = path.join(filesDir, rel.replace(/[\\/]/g, "__"));
     fs.copyFileSync(source, target);
     chmodPrivate(target);
-    const item = {
-      path: rel,
-      exists: true,
-      bytes: fs.statSync(source).size,
-      sha256: sha256File(source),
-    };
-    preserved.push(item);
-    backedUp.push(item);
   }
 
+  const backedUp = preserved.filter((item) => item.exists !== false);
+
   if (options.plan) {
     fs.writeFileSync(
       path.join(backupDir, "update-plan.json"),
@@ -96,14 +104,15 @@ export function createRuntimeBackup(ctx, backupDir, options = {}) {
     `${JSON.stringify({
       schema: "pi67.update-backup.v1",
       createdAt: new Date().toISOString(),
-      operation: options.operation || "update",
+      operation,
       agentDir: ctx.agentDir,
       repoRoot: ctx.repoRoot,
       files: preserved,
     }, null, 2)}\n`,
     { mode: 0o600 },
   );
-  return backedUp;
+  const result = { backupDir, backedUp, skipped: false, reusedBackupDir: "", reason: "" };
+  return options.returnResult ? result : backedUp;
 }
 
 export function listRuntimeBackups(ctx) {
@@ -246,6 +255,39 @@ function isStaleLock(lockPath) {
   return false;
 }
 
+function collectPreservedRuntimeFiles(ctx) {
+  return PRESERVED_RUNTIME_FILES.map((rel) => {
+    const source = path.join(ctx.agentDir, rel);
+    if (!fs.existsSync(source)) {
+      return { path: rel, exists: false };
+    }
+    const stat = fs.statSync(source);
+    return {
+      path: rel,
+      exists: true,
+      bytes: stat.size,
+      sha256: sha256File(source),
+    };
+  });
+}
+
+function findEquivalentRuntimeBackup(ctx, preserved, operation) {
+  return listRuntimeBackups(ctx).find((backup) =>
+    backup.operation === operation && sameRuntimeFiles(backup.files, preserved));
+}
+
+function sameRuntimeFiles(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+  const leftByPath = new Map(left.map((item) => [item.path, item]));
+  return right.every((rightItem) => {
+    const leftItem = leftByPath.get(rightItem.path);
+    if (!leftItem) return false;
+    if ((leftItem.exists !== false) !== (rightItem.exists !== false)) return false;
+    if (rightItem.exists === false) return true;
+    return leftItem.bytes === rightItem.bytes && leftItem.sha256 === rightItem.sha256;
+  });
+}
+
 function sha256File(file) {
   const hash = crypto.createHash("sha256");
   hash.update(fs.readFileSync(file));