@daemux/store-automator 0.10.63 → 0.10.64

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.63"
+    "version": "0.10.64"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.63",
+      "version": "0.10.64",
       "keywords": [
         "flutter",
         "app-store",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.63",
+  "version": "0.10.64",
   "description": "Full App Store & Google Play automation for Flutter apps with Claude Code agents",
   "type": "module",
   "bin": {

package/plugins/store-automator/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "store-automator",
-  "version": "0.10.63",
+  "version": "0.10.64",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"

package/src/backup.mjs

@@ -0,0 +1,99 @@
+import {
+  existsSync, mkdirSync, readFileSync, writeFileSync,
+  readdirSync, rmSync, statSync,
+} from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+
+const BACKUP_ROOT = join(homedir(), '.claude', 'backups', 'store-automator');
+const RETAIN_COUNT = 10;
+
+function utcTimestamp() {
+  return new Date().toISOString().slice(0, 19).replace(/:/g, '');
+}
+
+function sha256(buf) {
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+function writeBackupFile(filePath, contentBuf) {
+  const ts = utcTimestamp();
+  const dir = join(BACKUP_ROOT, ts);
+  const dest = join(dir, `${basename(filePath)}.bak`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(dest, contentBuf);
+  console.log(`Backup written to: ${dest}`);
+  return dest;
+}
+
+export function backupIfChanging(filePath, newContent) {
+  if (!existsSync(filePath)) {
+    return { backedUp: false, path: null };
+  }
+
+  const current = readFileSync(filePath);
+  const incoming = Buffer.isBuffer(newContent) ? newContent : Buffer.from(newContent, 'utf8');
+  if (sha256(current) === sha256(incoming)) {
+    return { backedUp: false, path: null };
+  }
+
+  const dest = writeBackupFile(filePath, current);
+  return { backedUp: true, path: dest };
+}
+
+// Snapshot arbitrary content to a timestamped backup. Used for post-hoc backups
+// when the caller only has access to pre-mutation content after the fact
+// (e.g. functions that mutate the target file in place).
+// No-op if preContent already matches postContent (nothing really changed).
+export function backupSnapshot(filePath, preContent, postContent) {
+  if (preContent == null) return { backedUp: false, path: null };
+  if (preContent === postContent) return { backedUp: false, path: null };
+  const buf = Buffer.isBuffer(preContent) ? preContent : Buffer.from(preContent, 'utf8');
+  const dest = writeBackupFile(filePath, buf);
+  return { backedUp: true, path: dest };
+}
+
+function listBackupEntries() {
+  if (!existsSync(BACKUP_ROOT)) return [];
+  const entries = [];
+  for (const tsDir of readdirSync(BACKUP_ROOT)) {
+    const tsPath = join(BACKUP_ROOT, tsDir);
+    let s;
+    try { s = statSync(tsPath); } catch { continue; }
+    if (!s.isDirectory()) continue;
+    for (const file of readdirSync(tsPath)) {
+      const fullPath = join(tsPath, file);
+      entries.push({ basename: file, ts: tsDir, fullPath, tsDir: tsPath });
+    }
+  }
+  return entries;
+}
+
+export function pruneBackups() {
+  const entries = listBackupEntries();
+  if (entries.length === 0) return;
+
+  const byBasename = new Map();
+  for (const e of entries) {
+    if (!byBasename.has(e.basename)) byBasename.set(e.basename, []);
+    byBasename.get(e.basename).push(e);
+  }
+
+  const toDelete = [];
+  for (const group of byBasename.values()) {
+    group.sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0));
+    toDelete.push(...group.slice(RETAIN_COUNT));
+  }
+
+  for (const e of toDelete) {
+    try { rmSync(e.fullPath, { force: true }); } catch { /* ignore */ }
+  }
+
+  const touchedTsDirs = new Set(toDelete.map((e) => e.tsDir));
+  for (const tsDir of touchedTsDirs) {
+    try {
+      if (readdirSync(tsDir).length === 0) rmSync(tsDir, { recursive: true, force: true });
+    } catch { /* ignore */ }
+  }
+}

package/src/install.mjs

@@ -1,4 +1,4 @@
-import { existsSync, rmSync, cpSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync, cpSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -13,6 +13,8 @@ import { getMcpServers, writeMcpJson } from './mcp-setup.mjs';
 import { installClaudeMd, installCiTemplates, installFirebaseTemplates } from './templates.mjs';
 import { readCiConfig, writeCiFields, writeCiLanguages, writeMatchConfig, isPlaceholder } from './ci-config.mjs';
 import { installGitHubActionsPath } from './install-paths.mjs';
+import { backupSnapshot, pruneBackups } from './backup.mjs';
+import { writeManagedSettings } from './managed-settings.mjs';
 
 function checkClaudeCli() {
   const result = exec('command -v claude') || exec('which claude');
@@ -162,13 +164,29 @@ async function withReadline(fn) {
   }
 }
 
+function readIfExists(filePath) {
+  return existsSync(filePath) ? readFileSync(filePath, 'utf8') : null;
+}
+
 function configureScopedSettings(baseDir, packageDir, appName, scopeLabel) {
   ensureDir(baseDir);
   installClaudeMd(join(baseDir, 'CLAUDE.md'), packageDir, appName);
   console.log(`Configuring ${scopeLabel} settings...`);
   const settingsPath = join(baseDir, 'settings.json');
+
+  // Snapshot pre-mutation state so we can back it up if inject* changes anything.
+  // inject* functions mutate in place (ensureFile creates {} when missing), so the
+  // backup must capture state before they run and be written only if a real change
+  // occurred — otherwise re-running install would churn backups on every invocation.
+  const preContent = readIfExists(settingsPath);
+
   injectEnvVars(settingsPath);
   injectStatusLine(settingsPath);
+
+  const postContent = readIfExists(settingsPath) ?? '';
+  backupSnapshot(settingsPath, preContent, postContent);
+
+  writeManagedSettings(baseDir);
 }
 
 function printGlobalNote() {
@@ -253,6 +271,8 @@ export async function runInstall(scope, isPostinstall = false, cliTokens = {}) {
   const appName = prompted.appName || (isGlobal ? 'your app' : undefined);
   configureScopedSettings(baseDir, packageDir, appName, isGlobal ? 'global' : 'project');
 
+  pruneBackups();
+
   printSummary(scope, oldVersion, newVersion);
   if (isGlobal) {
     printGlobalNote();

package/src/managed-settings.mjs

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const LEDGER_FILENAME = 'store-automator-managed-settings.json';
+
+export const HISTORICAL_ENV_VALUES = {
+  'CLAUDE_CODE_ENABLE_TASKS': 'true',
+  'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS': '1',
+};
+
+export const HISTORICAL_ENV_KEYS = Object.keys(HISTORICAL_ENV_VALUES);
+
+// Ledger is scoped to the settings.json baseDir (e.g. ~/.claude for global or
+// <project>/.claude for project). Keeping it adjacent to the settings file it
+// describes prevents global/project scope overlap.
+export function getLedgerPath(baseDir) {
+  return join(baseDir, LEDGER_FILENAME);
+}
+
+function getSettingsPath(baseDir) {
+  return join(baseDir, 'settings.json');
+}
+
+function sortedStringify(value) {
+  return JSON.stringify(value, (_, v) => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      const out = {};
+      for (const key of Object.keys(v).sort()) out[key] = v[key];
+      return out;
+    }
+    return v;
+  }, 2) + '\n';
+}
+
+function readSettings(settingsPath) {
+  if (!existsSync(settingsPath)) return {};
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function writeManagedSettings(baseDir) {
+  const settingsPath = getSettingsPath(baseDir);
+  const ledgerPath = getLedgerPath(baseDir);
+  const settings = readSettings(settingsPath);
+  const env = settings.env || {};
+
+  const envKeys = HISTORICAL_ENV_KEYS
+    .filter((k) => Object.prototype.hasOwnProperty.call(env, k))
+    .sort();
+
+  const envValues = {};
+  for (const k of envKeys) envValues[k] = env[k];
+
+  const statusLineValue = settings.statusLine;
+  const hasExpectedStatusLine = Boolean(
+    statusLineValue
+    && typeof statusLineValue === 'object'
+    && statusLineValue.type === 'command'
+    && typeof statusLineValue.command === 'string'
+    && statusLineValue.command.includes('context_window'),
+  );
+
+  const ledger = {
+    schemaVersion: 1,
+    plugin: 'daemux-store-automator',
+    envKeys,
+    envValues,
+    statusLine: hasExpectedStatusLine
+      ? { wasSet: true, content: statusLineValue }
+      : { wasSet: false, content: null },
+  };
+
+  mkdirSync(dirname(ledgerPath), { recursive: true });
+  writeFileSync(ledgerPath, sortedStringify(ledger), 'utf8');
+}
+
+export function readManagedSettings(baseDir) {
+  const ledgerPath = getLedgerPath(baseDir);
+  if (!existsSync(ledgerPath)) return null;
+  try {
+    return JSON.parse(readFileSync(ledgerPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}

package/src/settings.mjs

@@ -1,4 +1,3 @@
-import { existsSync } from 'node:fs';
 import { ensureFile, readJson, writeJson } from './utils.mjs';
 
 const ENV_DEFAULTS = {
@@ -47,28 +46,6 @@ export function injectEnvVars(settingsPath) {
   }
 }
 
-export function removeEnvVars(settingsPath) {
-  if (!existsSync(settingsPath)) return;
-
-  try {
-    const settings = readJson(settingsPath);
-    if (!settings.env) return;
-
-    for (const key of Object.keys(ENV_DEFAULTS)) {
-      delete settings.env[key];
-    }
-
-    if (Object.keys(settings.env).length === 0) {
-      delete settings.env;
-    }
-
-    writeJson(settingsPath, settings);
-    console.log('Removed env vars');
-  } catch {
-    // Silently skip if settings file is invalid
-  }
-}
-
 export function injectStatusLine(settingsPath) {
   try {
     ensureFile(settingsPath);
@@ -90,17 +67,3 @@ export function injectStatusLine(settingsPath) {
   }
 }
 
-export function removeStatusLine(settingsPath) {
-  if (!existsSync(settingsPath)) return;
-
-  try {
-    const settings = readJson(settingsPath);
-    if (!settings.statusLine) return;
-
-    delete settings.statusLine;
-    writeJson(settingsPath, settings);
-    console.log('Removed statusLine configuration');
-  } catch {
-    // Silently skip if settings file is invalid
-  }
-}

package/src/templates.mjs

@@ -1,6 +1,11 @@
 import { existsSync, cpSync, copyFileSync, chmodSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './utils.mjs';
+import { backupIfChanging } from './backup.mjs';
+
+const SENTINEL_BEGIN = '<!-- BEGIN daemux-store-automator -->';
+const SENTINEL_END = '<!-- END daemux-store-automator -->';
+const SENTINEL_BLOCK_RE = /<!-- BEGIN daemux-store-automator -->[\s\S]*?<!-- END daemux-store-automator -->/;
 
 const FILE_COPIES = [
   ['ci.config.yaml.template', 'ci.config.yaml'],
@@ -46,18 +51,60 @@ function copyIfMissing(srcPath, destPath, label, isDirectory) {
   }
 }
 
+function wrapInSentinels(body) {
+  const trimmed = body.replace(/\s+$/, '');
+  return `${SENTINEL_BEGIN}\n${trimmed}\n${SENTINEL_END}\n`;
+}
+
+function looksLikeUnsentineledPluginContent(existing) {
+  if (!existing) return false;
+  const startsWithHeader = /^#\s.+-\s*Development Standards\b/m.test(existing.split('\n').slice(0, 5).join('\n'));
+  const hasFastlane = existing.includes('fastlane');
+  return startsWithHeader && hasFastlane;
+}
+
+function composeNewFileContent(existing, wrappedBlock) {
+  if (!existing) {
+    return wrappedBlock;
+  }
+  if (SENTINEL_BLOCK_RE.test(existing)) {
+    return existing.replace(SENTINEL_BLOCK_RE, wrappedBlock.replace(/\n$/, ''));
+  }
+  if (looksLikeUnsentineledPluginContent(existing)) {
+    return wrappedBlock;
+  }
+  const sep = existing.endsWith('\n') ? '' : '\n';
+  return `${existing}${sep}\n${wrappedBlock}`;
+}
+
 export function installClaudeMd(targetPath, packageDir, appName) {
   const template = join(packageDir, 'templates', 'CLAUDE.md.template');
   if (!existsSync(template)) return;
-  const action = existsSync(targetPath) ? 'Updating' : 'Installing';
+  const targetExists = existsSync(targetPath);
+  const action = targetExists ? 'Updating' : 'Installing';
   console.log(`${action} CLAUDE.md...`);
   ensureDir(join(targetPath, '..'));
 
-  let content = readFileSync(template, 'utf8');
+  let body = readFileSync(template, 'utf8');
   if (appName) {
-    content = content.split('{APP_NAME}').join(appName);
+    body = body.split('{APP_NAME}').join(appName);
   }
-  writeFileSync(targetPath, content, 'utf8');
+  const wrappedBlock = wrapInSentinels(body);
+
+  const existing = targetExists ? readFileSync(targetPath, 'utf8') : '';
+  const migrating = targetExists
+    && !SENTINEL_BLOCK_RE.test(existing)
+    && looksLikeUnsentineledPluginContent(existing);
+
+  const newContent = composeNewFileContent(existing, wrappedBlock);
+
+  const backupResult = backupIfChanging(targetPath, newContent);
+  if (migrating) {
+    const backupPath = backupResult.path || '(no backup needed — content identical)';
+    console.log(`Migrating unsentineled plugin content to sentinel-wrapped form (backup: ${backupPath})`);
+  }
+
+  writeFileSync(targetPath, newContent, 'utf8');
 }
 
 export function installCiTemplates(projectDir, packageDir) {

package/src/uninstall.mjs

@@ -1,4 +1,7 @@
-import { existsSync, rmSync, unlinkSync, readdirSync } from 'node:fs';
+import {
+  existsSync, rmSync, unlinkSync, readdirSync,
+  readFileSync, writeFileSync,
+} from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
@@ -7,8 +10,15 @@ import {
   MARKETPLACE_NAME, PLUGIN_REF,
   readJson, writeJson,
 } from './utils.mjs';
-import { removeEnvVars, removeStatusLine } from './settings.mjs';
 import { removeMcpServers } from './mcp-setup.mjs';
+import { backupIfChanging, pruneBackups } from './backup.mjs';
+import {
+  readManagedSettings, getLedgerPath,
+  HISTORICAL_ENV_KEYS, HISTORICAL_ENV_VALUES,
+} from './managed-settings.mjs';
+
+const SENTINEL_BEGIN = '<!-- BEGIN daemux-store-automator -->';
+const SENTINEL_END = '<!-- END daemux-store-automator -->';
 
 function runClaudeUninstall(scope) {
   const scopeArg = scope === 'user' ? '' : ` --scope ${scope}`;
@@ -81,27 +91,134 @@ function removeGitHubWorkflow(projectDir) {
   }
 }
 
-export async function runUninstall(scope) {
-  console.log(`Uninstalling Daemux Store Automator (scope: ${scope})...`);
+function spliceSentinelBlock(content) {
+  const beginIdx = content.indexOf(SENTINEL_BEGIN);
+  const endIdx = content.indexOf(SENTINEL_END);
+  if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) return null;
 
-  runClaudeUninstall(scope);
+  const before = content.slice(0, beginIdx);
+  let after = content.slice(endIdx + SENTINEL_END.length);
+  if (after.startsWith('\n')) after = after.slice(1);
+  return before.replace(/[ \t]+$/, '') + after;
+}
 
-  let doneMessage;
-  if (scope === 'user') {
-    console.log('Removing marketplace...');
-    rmSync(MARKETPLACE_DIR, { recursive: true, force: true });
-    rmSync(CACHE_DIR, { recursive: true, force: true });
-    unregisterMarketplace();
-    doneMessage = '\nDone! store-automator uninstalled globally.';
+function cleanClaudeMd(baseDir, scopeLabel) {
+  const claudeMdPath = join(baseDir, 'CLAUDE.md');
+  if (!existsSync(claudeMdPath)) return;
+
+  const content = readFileSync(claudeMdPath, 'utf8');
+  const spliced = spliceSentinelBlock(content);
+
+  if (spliced === null) {
+    console.log(
+      `Warning: ${scopeLabel} CLAUDE.md has no plugin sentinels; leaving untouched. ` +
+      `(If this file contains plugin content from an older version, remove the plugin section manually.)`
+    );
+    return;
+  }
+
+  backupIfChanging(claudeMdPath, spliced);
+  if (spliced.trim() === '') {
+    rmSync(claudeMdPath);
+    console.log(`Removed ${scopeLabel} CLAUDE.md (contained only plugin content)`);
   } else {
-    doneMessage = '\nDone! store-automator uninstalled from this project.\n\nNote: Marketplace files remain under ~/.claude/plugins/marketplaces.\nRun with --global --uninstall to remove marketplace completely.';
+    writeFileSync(claudeMdPath, spliced, 'utf8');
+    console.log(`Removed plugin section from ${scopeLabel} CLAUDE.md`);
   }
+}
+
+function looksLikeHistoricalPluginStatusLine(current) {
+  return Boolean(
+    current
+    && typeof current === 'object'
+    && current.type === 'command'
+    && typeof current.command === 'string'
+    && current.command.includes('context_window')
+  );
+}
+
+function pruneManagedEnv(settings, envKeys, envValues) {
+  if (!settings.env) return false;
+  let modified = false;
+  for (const key of envKeys) {
+    if (!(key in settings.env)) continue;
+    const expected = envValues ? envValues[key] : undefined;
+    if (expected === undefined || settings.env[key] === expected) {
+      delete settings.env[key];
+      modified = true;
+    } else {
+      console.log(`Preserving user-modified env.${key} in settings.json`);
+    }
+  }
+  if (Object.keys(settings.env).length === 0) delete settings.env;
+  return modified;
+}
+
+function pruneManagedStatusLine(settings, ledgerStatusLine) {
+  if (!settings.statusLine) return false;
+
+  if (ledgerStatusLine) {
+    if (ledgerStatusLine.wasSet !== true) return false;
+    const managed = ledgerStatusLine.content;
+    if (JSON.stringify(settings.statusLine) !== JSON.stringify(managed)) {
+      console.log('Preserving user-modified statusLine in settings.json');
+      return false;
+    }
+    delete settings.statusLine;
+    return true;
+  }
+
+  if (!looksLikeHistoricalPluginStatusLine(settings.statusLine)) {
+    console.log('Preserving non-plugin statusLine in settings.json (no ledger, signature mismatch)');
+    return false;
+  }
+  delete settings.statusLine;
+  return true;
+}
+
+function cleanSettings(baseDir, scopeLabel, ledger) {
+  const settingsPath = join(baseDir, 'settings.json');
+  if (!existsSync(settingsPath)) return;
+
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return;
+  }
+
+  const envKeys = ledger?.envKeys ?? HISTORICAL_ENV_KEYS;
+  const envValues = ledger?.envValues ?? HISTORICAL_ENV_VALUES;
+  const envChanged = pruneManagedEnv(settings, envKeys, envValues);
+  const statusLineChanged = pruneManagedStatusLine(settings, ledger?.statusLine);
+
+  if (!envChanged && !statusLineChanged) return;
+
+  const newRaw = JSON.stringify(settings, null, 2) + '\n';
+  backupIfChanging(settingsPath, newRaw);
+  writeFileSync(settingsPath, newRaw, 'utf8');
+  console.log(`Cleaned ${scopeLabel} settings`);
+}
+
+function removeLedger(baseDir) {
+  const ledgerPath = getLedgerPath(baseDir);
+  if (existsSync(ledgerPath)) {
+    try { rmSync(ledgerPath); } catch { /* best-effort */ }
+  }
+}
+
+export async function runUninstall(scope) {
+  console.log(`Uninstalling Daemux Store Automator (scope: ${scope})...`);
+
+  runClaudeUninstall(scope);
 
   const isGlobal = scope === 'user';
   const baseDir = isGlobal ? join(homedir(), '.claude') : join(process.cwd(), '.claude');
   const scopeLabel = isGlobal ? 'global' : 'project';
 
-  removeFileIfExists(join(baseDir, 'CLAUDE.md'), `${scopeLabel} CLAUDE.md`);
+  const ledger = readManagedSettings(baseDir);
+
+  cleanClaudeMd(baseDir, scopeLabel);
 
   if (!isGlobal) {
     removeCiTemplates(process.cwd());
@@ -109,8 +226,21 @@ export async function runUninstall(scope) {
   }
 
   console.log(`Cleaning ${scopeLabel} settings...`);
-  removeEnvVars(join(baseDir, 'settings.json'));
-  removeStatusLine(join(baseDir, 'settings.json'));
+  cleanSettings(baseDir, scopeLabel, ledger);
+
+  removeLedger(baseDir);
+  pruneBackups();
+
+  let doneMessage;
+  if (isGlobal) {
+    console.log('Removing marketplace...');
+    rmSync(MARKETPLACE_DIR, { recursive: true, force: true });
+    rmSync(CACHE_DIR, { recursive: true, force: true });
+    unregisterMarketplace();
+    doneMessage = '\nDone! store-automator uninstalled globally.';
+  } else {
+    doneMessage = '\nDone! store-automator uninstalled from this project.\n\nNote: Marketplace files remain under ~/.claude/plugins/marketplaces.\nRun with --global --uninstall to remove marketplace completely.';
+  }
 
   console.log(doneMessage);
 }