gsd-lite 0.3.15 → 0.3.17

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "name": "gsd",
       "source": "./",
       "description": "AI orchestration tool — GSD management shell + Superpowers quality core. 5 commands, 4 agents, 5 workflows, MCP server, context monitoring.",
-      "version": "0.3.15",
+      "version": "0.3.17",
       "keywords": [
         "orchestration",
         "mcp",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "AI orchestration tool for Claude Code — GSD management shell + Superpowers quality core",
   "author": {
     "name": "sdsrss",

package/cli.js

@@ -40,7 +40,11 @@ switch (command) {
     if (result?.updated) {
       console.log(`\n✓ Updated: v${result.from} → v${result.to}`);
     } else if (result?.updateAvailable) {
-      console.log(`\n! Update available v${result.to} but install failed. Try manually.`);
+      if (result.action === 'plugin_update') {
+        console.log(`\n! Update available: v${result.to}. Run /plugin update gsd`);
+      } else {
+        console.log(`\n! Update available v${result.to} but install failed. Try manually.`);
+      }
     } else if (!result) {
       console.log('✓ Already up to date');
     }

package/hooks/gsd-auto-update.cjs

@@ -20,104 +20,200 @@ const claudeDir =
 const runtimeDir = path.join(claudeDir, 'gsd');
 const stateDir = path.join(runtimeDir, 'runtime');
 const STATE_FILE = path.join(stateDir, 'update-state.json');
+const STATE_LOCK_FILE = path.join(stateDir, 'update-state.lock');
+const NOTIFICATION_FILE = path.join(stateDir, 'update-notification.json');
 const pluginRoot = path.resolve(__dirname, '..');
 
+const LOCK_STALE_MS = 10_000;
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+
 // ── Main Entry ─────────────────────────────────────────────
 async function checkForUpdate(options = {}) {
-  const { force = false, verbose = false, install = true } = options;
+  const {
+    force = false,
+    verbose = false,
+    install = true,
+    notify = false,
+    fetchLatestRelease: fetchLatestReleaseImpl = fetchLatestRelease,
+    downloadAndInstall: downloadAndInstallImpl = downloadAndInstall,
+    getCurrentVersion: getCurrentVersionImpl = getCurrentVersion,
+  } = options;
+  const installMode = getInstallMode();
 
   try {
     if (!force && shouldSkipUpdateCheck()) {
       if (verbose) console.log('Skipping update check (dev mode or auto-update in progress)');
       return null;
     }
-
-    const state = readState();
-    if (!force && !shouldCheck(state)) {
-      if (state.updateAvailable && state.latestVersion) {
-        return {
-          updateAvailable: true,
-          from: getCurrentVersion(),
-          to: state.latestVersion,
-        };
+    return await withFileLock(async () => {
+      const state = readState();
+      if (!force && !shouldCheck(state)) {
+        if (state.updateAvailable && state.latestVersion) {
+          return {
+            updateAvailable: true,
+            from: getCurrentVersionImpl(installMode),
+            to: state.latestVersion,
+            installMode,
+          };
+        }
+        if (verbose) console.log('Throttled — last check:', state.lastCheck);
+        return null;
       }
-      if (verbose) console.log('Throttled — last check:', state.lastCheck);
-      return null;
-    }
 
-    if (verbose) console.log('Checking GitHub for latest release...');
-    const token = getGitHubToken();
-    const latest = await fetchLatestRelease(token);
-    if (!latest) {
-      if (latest === false) state.rateLimited = true; // 403 rate-limited
-      saveState({ ...state, lastCheck: new Date().toISOString() });
-      if (verbose) console.log('Could not fetch latest release');
-      return null;
-    }
-
-    // Successful fetch — clear rate-limit back-off
-    state.rateLimited = false;
-    const currentVersion = getCurrentVersion();
-    if (verbose) console.log(`Current: v${currentVersion} — Latest: v${latest.version}`);
+      if (verbose) console.log('Checking GitHub for latest release...');
+      const token = getGitHubToken();
+      const latest = await fetchLatestReleaseImpl(token);
+      if (!latest) {
+        if (latest === false) state.rateLimited = true; // 403 rate-limited
+        saveState({ ...state, lastCheck: new Date().toISOString() });
+        if (verbose) console.log('Could not fetch latest release');
+        return null;
+      }
 
-    const hasUpdate = compareVersions(latest.version, currentVersion) > 0;
+      // Successful fetch — clear rate-limit back-off
+      state.rateLimited = false;
+      const currentVersion = getCurrentVersionImpl(installMode);
+      if (verbose) console.log(`Current: v${currentVersion} — Latest: v${latest.version}`);
+
+      const hasUpdate = compareVersions(latest.version, currentVersion) > 0;
+
+      if (hasUpdate) {
+        if (installMode === 'plugin' && install) {
+          saveState({
+            ...state,
+            lastCheck: new Date().toISOString(),
+            latestVersion: latest.version,
+            updateAvailable: true,
+          });
+          if (notify) {
+            writeNotification({
+              kind: 'available',
+              from: currentVersion,
+              to: latest.version,
+              action: 'plugin_update',
+            });
+          }
+          return {
+            updateAvailable: true,
+            from: currentVersion,
+            to: latest.version,
+            action: 'plugin_update',
+            autoInstallSupported: false,
+            installMode,
+          };
+        }
+
+        if (!install) {
+          // Check-only mode (used by SessionStart hook)
+          saveState({
+            ...state,
+            lastCheck: new Date().toISOString(),
+            latestVersion: latest.version,
+            updateAvailable: true,
+          });
+          return {
+            updateAvailable: true,
+            from: currentVersion,
+            to: latest.version,
+            installMode,
+          };
+        }
+
+        if (verbose) console.log(`Downloading v${latest.version}...`);
+        const success = await downloadAndInstallImpl(latest.tarballUrl, verbose, token);
 
-    if (hasUpdate) {
-      if (!install) {
-        // Check-only mode (used by SessionStart hook)
         saveState({
           ...state,
           lastCheck: new Date().toISOString(),
           latestVersion: latest.version,
-          updateAvailable: true,
+          updateAvailable: !success,
+          lastUpdate: success ? new Date().toISOString() : state.lastUpdate,
         });
+
+        if (success && notify) {
+          writeNotification({
+            kind: 'updated',
+            from: currentVersion,
+            to: latest.version,
+          });
+        }
+
         return {
-          updateAvailable: true,
+          updateAvailable: !success,
+          updated: success,
           from: currentVersion,
           to: latest.version,
+          installMode,
         };
       }
 
-      if (verbose) console.log(`Downloading v${latest.version}...`);
-      const success = await downloadAndInstall(latest.tarballUrl, verbose, token);
-
+      // No update needed
       saveState({
         ...state,
         lastCheck: new Date().toISOString(),
         latestVersion: latest.version,
-        updateAvailable: !success,
-        lastUpdate: success ? new Date().toISOString() : state.lastUpdate,
+        updateAvailable: false,
       });
-
-      return {
-        updateAvailable: !success,
-        updated: success,
-        from: currentVersion,
-        to: latest.version,
-      };
-    }
-
-    // No update needed
-    saveState({
-      ...state,
-      lastCheck: new Date().toISOString(),
-      latestVersion: latest.version,
-      updateAvailable: false,
+      if (verbose) console.log('Already up to date');
+      return null;
     });
-    if (verbose) console.log('Already up to date');
-    return null;
   } catch (err) {
     if (verbose) console.error('Update check failed:', err.message);
     return null;
   }
 }
 
+async function withFileLock(fn) {
+  let acquired = false;
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      fs.writeFileSync(STATE_LOCK_FILE, String(process.pid), { flag: 'wx' });
+      acquired = true;
+      break;
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        try {
+          const stats = fs.statSync(STATE_LOCK_FILE);
+          if (Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+            try { fs.rmSync(STATE_LOCK_FILE, { force: true }); } catch {}
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_MS));
+      } else {
+        break;
+      }
+    }
+  }
+
+  try {
+    return await fn();
+  } finally {
+    if (acquired) {
+      try { fs.rmSync(STATE_LOCK_FILE, { force: true }); } catch {}
+    }
+  }
+}
+
 // ── Skip Check Detection ──────────────────────────────────
 // Returns true when update checks should be skipped:
 // 1. PLUGIN_AUTO_UPDATE env set → recursive guard (auto-update already in progress)
 // 2. Running from a git clone → dev mode (developer working on source)
 function shouldSkipUpdateCheck() {
   if (process.env.PLUGIN_AUTO_UPDATE) return true;
+  return isDevMode();
+}
+
+function isDevMode() {
   try {
     if (!fs.existsSync(path.join(pluginRoot, '.git'))) return false;
     const pkg = JSON.parse(
@@ -129,6 +225,13 @@ function shouldSkipUpdateCheck() {
   }
 }
 
+function getInstallMode() {
+  if (isDevMode()) return 'dev';
+  return path.resolve(pluginRoot) === path.resolve(claudeDir)
+    ? 'manual'
+    : 'plugin';
+}
+
 // ── Throttle ───────────────────────────────────────────────
 function shouldCheck(state) {
   if (!state.lastCheck) return true;
@@ -196,11 +299,11 @@ function compareVersions(a, b) {
   return 0;
 }
 
-function getCurrentVersion() {
-  for (const p of [
-    path.join(pluginRoot, 'package.json'),
-    path.join(runtimeDir, 'package.json'),
-  ]) {
+function getCurrentVersion(mode = getInstallMode()) {
+  const candidates = mode === 'manual'
+    ? [path.join(runtimeDir, 'package.json'), path.join(pluginRoot, 'package.json')]
+    : [path.join(pluginRoot, 'package.json'), path.join(runtimeDir, 'package.json')];
+  for (const p of candidates) {
     try {
       return JSON.parse(fs.readFileSync(p, 'utf8')).version;
     } catch {
@@ -280,9 +383,30 @@ function saveState(state) {
   }
 }
 
+function writeNotification(notification) {
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+    const tmpPath = NOTIFICATION_FILE + `.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify(notification, null, 2) + '\n');
+    fs.renameSync(tmpPath, NOTIFICATION_FILE);
+  } catch {
+    /* silent */
+  }
+}
+
 module.exports = {
   checkForUpdate,
   getCurrentVersion,
   compareVersions,
+  getInstallMode,
+  isDevMode,
+  shouldCheck,
   shouldSkipUpdateCheck,
 };
+
+// ── CLI Entry Point (for background auto-install) ─────────
+if (require.main === module) {
+  checkForUpdate({ install: true, verbose: false, notify: true })
+    .catch(() => {})
+    .finally(() => process.exit(0));
+}

package/hooks/gsd-session-init.cjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 // GSD-Lite SessionStart hook
-// 1. Auto-registers statusLine in settings.json if not already configured.
-// 2. Checks for updates and notifies user (no download in hook context).
+// 1. Cleans up stale temp files (throttled to once/day).
+// 2. Auto-registers statusLine in settings.json if not already configured.
+// 3. Shows notification if a previous background update completed or found a new version.
+// 4. Spawns background auto-update (detached, non-blocking).
 // Idempotent: skips if statusLine already points to gsd-statusline, preserves
 // third-party statuslines.
 
@@ -64,15 +66,31 @@ setTimeout(() => process.exit(0), 4000).unref();
     }
   } catch { /* silent */ }
 
-  // ── Phase 3: Auto-update check (notify only, no download) ──
-  // checkForUpdate handles throttling internally via shouldCheck()
+  // ── Phase 3: Show notification from previous background auto-install ──
   try {
-    const { checkForUpdate } = require('./gsd-auto-update.cjs');
-    const result = await checkForUpdate({ install: false });
-    if (result?.updateAvailable) {
-      console.log(
-        `\n📦 GSD-Lite v${result.to} available (current: v${result.from}). Run: gsd update`
-      );
+    const notifPath = path.join(claudeDir, 'gsd', 'runtime', 'update-notification.json');
+    if (fs.existsSync(notifPath)) {
+      const notif = JSON.parse(fs.readFileSync(notifPath, 'utf8'));
+      if (notif.kind === 'updated') {
+        console.log(`✅ GSD-Lite auto-updated: v${notif.from} → v${notif.to}`);
+      } else if (notif.kind === 'available' && notif.action === 'plugin_update') {
+        console.log(`📦 GSD-Lite update available: v${notif.from} → v${notif.to}. Run /plugin update gsd`);
+      } else if (notif.kind === 'available') {
+        console.log(`📦 GSD-Lite update available: v${notif.from} → v${notif.to}. Run gsd update`);
+      }
+      fs.unlinkSync(notifPath);
     }
+  } catch { /* silent */ }
+
+  // ── Phase 4: Spawn background auto-update (non-blocking) ──
+  // Detached child handles check + download + install; throttled by shouldCheck()
+  try {
+    const { spawn } = require('node:child_process');
+    const child = spawn(
+      process.execPath,
+      [path.join(__dirname, 'gsd-auto-update.cjs')],
+      { detached: true, stdio: 'ignore' },
+    );
+    child.unref();
   } catch { /* silent — never block session start */ }
 })().catch(() => {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-lite",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "AI orchestration tool for Claude Code — GSD management shell + Superpowers quality core",
   "type": "module",
   "bin": {