cursor-guard 4.9.6 → 4.9.9

package/references/vscode-extension/dist/guard-version.json

@@ -1 +1 @@
-{"version":"4.9.6"}
+{"version":"4.9.9"}

package/references/vscode-extension/dist/lib/core/snapshot.js

@@ -91,6 +91,8 @@ function buildCommitMessage(ts, opts) {
  * @param {string} [opts.context.intent] - Why this snapshot was created (e.g. "refactoring auth middleware")
  * @param {string} [opts.context.agent] - AI model identifier (e.g. "claude-4-opus")
  * @param {string} [opts.context.session] - Conversation/session ID
+ * @param {boolean} [opts.allowEmptyTree] - If true, still create a commit when the snapshot tree equals the previous ref (empty / bookmark commit). Auto-backup should omit this; explicit manual snapshots should set it.
+ * @param {boolean} [opts.fullWorkspaceSnapshot] - If true, ignore `cfg.protect` when building the snapshot tree (still apply `ignore` / secrets). Use for IDE/MCP "snapshot everything" so edits outside protect patterns are not invisible to the snapshot.
  * @returns {{ status: 'created'|'skipped'|'error', commitHash?: string, shortHash?: string, fileCount?: number, reason?: string, error?: string, secretsExcluded?: string[] }}
  */
 function createGitSnapshot(projectDir, cfg, opts = {}) {
@@ -99,6 +101,8 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
   const gDir = getGitDir(projectDir);
   if (!gDir) return { status: 'error', error: 'not a git repository' };
 
+  const narrowProtect = cfg.protect.length > 0 && !opts.fullWorkspaceSnapshot;
+
   const guardIndex = path.join(gDir, 'cursor-guard-index');
   const guardIndexLock = guardIndex + '.lock';
   const env = { ...process.env, GIT_INDEX_FILE: guardIndex };
@@ -109,7 +113,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
   try {
     const parentHash = git(['rev-parse', '--verify', branchRef], { cwd, allowFail: true });
 
-    if (cfg.protect.length > 0) {
+    if (narrowProtect) {
       // protect uses strict matching (full path only, no basename fallback)
       // so *.js only matches root-level js files, not nested ones
       execFileSync('git', ['add', '-A'], { cwd, env, stdio: 'pipe' });
@@ -132,7 +136,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
       ? git(['rev-parse', `${branchRef}^{tree}`], { cwd, allowFail: true })
       : null;
 
-    if (newTree === parentTree) {
+    if (newTree === parentTree && !opts.allowEmptyTree) {
       return { status: 'skipped', reason: 'tree unchanged' };
     }
 
@@ -156,7 +160,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
             : 'M';
           const fileName = filePart.split('\t').pop();
           if (matchesAny(cfg.ignore, fileName) || matchesAny(cfg.ignore, path.basename(fileName))) continue;
-          if (cfg.protect.length > 0 && !matchesAny(cfg.protect, fileName, { strict: true })) continue;
+          if (narrowProtect && !matchesAny(cfg.protect, fileName, { strict: true })) continue;
           groups[key].push(fileName);
         }
         changedCount = Object.values(groups).reduce((sum, arr) => sum + arr.length, 0);
@@ -202,7 +206,7 @@ function createGitSnapshot(projectDir, cfg, opts = {}) {
       if (lsInitial) {
         const files = lsInitial.split('\n').filter(Boolean)
           .filter(f => !matchesAny(cfg.ignore, f) && !matchesAny(cfg.ignore, path.basename(f)))
-          .filter(f => cfg.protect.length === 0 || matchesAny(cfg.protect, f, { strict: true }));
+          .filter(f => !narrowProtect || matchesAny(cfg.protect, f, { strict: true }));
         changedCount = files.length;
         const sample = files.slice(0, 5).join(', ');
 

package/references/vscode-extension/dist/lib/dashboard-manager.js

@@ -7,11 +7,13 @@ const { spawn } = require('child_process');
 const { guardPath } = require('./paths');
 
 const CONFIG_FILE = '.cursor-guard.json';
+const WATCHER_START_GRACE_MS = 8000;
 
 class DashboardManager {
   constructor() {
     this._instance = null;
     this._serverModule = null;
+    this._startingWatchers = new Map();
   }
 
   get running() { return !!this._instance; }
@@ -89,12 +91,51 @@ class DashboardManager {
       const { createGitSnapshot } = require(guardPath('lib', 'core', 'snapshot'));
       const { loadConfig } = require(guardPath('lib', 'utils'));
       const { cfg } = loadConfig(projectPath);
-      return createGitSnapshot(projectPath, cfg, { message: 'guard: manual snapshot via IDE extension' });
+      return createGitSnapshot(projectPath, cfg, {
+        branchRef: 'refs/guard/snapshot',
+        message: `guard: manual snapshot via IDE (${new Date().toISOString()})`,
+        context: { trigger: 'manual' },
+        allowEmptyTree: true,
+        // Match user expectation: "Snapshot now" captures the whole repo (except ignore/secrets), not only protect globs
+        fullWorkspaceSnapshot: true,
+      });
     } catch (e) {
       return { status: 'error', error: e.message };
     }
   }
 
+  _getWatcherLockPath(projectPath) {
+    try {
+      const { gitAvailable, isGitRepo, gitDir: getGitDir } = require(guardPath('lib', 'utils'));
+      const repo = gitAvailable() && isGitRepo(projectPath);
+      if (repo) {
+        const gDir = getGitDir(projectPath);
+        if (gDir) return path.join(gDir, 'cursor-guard.lock');
+      }
+    } catch { /* ignore */ }
+    return path.join(projectPath, '.cursor-guard-backup', 'cursor-guard.lock');
+  }
+
+  _getPendingWatcherPid(projectPath) {
+    const pending = this._startingWatchers.get(projectPath);
+    if (!pending) return null;
+    try {
+      process.kill(pending.pid, 0);
+      return pending.pid;
+    } catch {
+      this._startingWatchers.delete(projectPath);
+      return null;
+    }
+  }
+
+  _clearPendingWatcher(projectPath, pid) {
+    const pending = this._startingWatchers.get(projectPath);
+    if (!pending) return;
+    if (pid == null || pending.pid === pid) {
+      this._startingWatchers.delete(projectPath);
+    }
+  }
+
   startWatcher(projectPath) {
     if (!projectPath) return null;
     const existingPid = this.getWatcherPid(projectPath);
@@ -106,33 +147,49 @@ class DashboardManager {
       detached: true,
       env: { ...process.env, GUARD_SPAWNED_BY_EXT: '1' },
     });
+    this._startingWatchers.set(projectPath, { pid: child.pid, startedAt: Date.now() });
+    const clearPending = () => this._clearPendingWatcher(projectPath, child.pid);
+    child.once('exit', clearPending);
+    child.once('error', clearPending);
+    setTimeout(clearPending, WATCHER_START_GRACE_MS);
     child.unref();
     return child.pid;
   }
 
   stopWatcher(projectPath) {
     if (!projectPath) return false;
+    const pendingPid = this._getPendingWatcherPid(projectPath);
+    if (pendingPid) {
+      try { process.kill(pendingPid, 'SIGTERM'); } catch { /* ignore */ }
+      this._clearPendingWatcher(projectPath, pendingPid);
+    }
     try {
-      const lockPath = path.join(projectPath, '.cursor-guard-backup.lock');
+      const lockPath = this._getWatcherLockPath(projectPath);
       if (!fs.existsSync(lockPath)) return false;
-      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
-      if (lockData.pid) {
-        process.kill(lockData.pid, 'SIGTERM');
-        try { fs.unlinkSync(lockPath); } catch { /* ok */ }
-        return true;
+      const content = fs.readFileSync(lockPath, 'utf-8');
+      const pidMatch = content.match(/pid=(\d+)/);
+      if (pidMatch) {
+        process.kill(parseInt(pidMatch[1], 10), 'SIGTERM');
       }
+      try { fs.unlinkSync(lockPath); } catch { /* ok */ }
+      return true;
     } catch { /* ok */ }
-    return false;
+    return !!pendingPid;
   }
 
   getWatcherPid(projectPath) {
+    const pendingPid = this._getPendingWatcherPid(projectPath);
+    if (pendingPid) return pendingPid;
     try {
-      const lockPath = path.join(projectPath, '.cursor-guard-backup.lock');
+      const lockPath = this._getWatcherLockPath(projectPath);
       if (!fs.existsSync(lockPath)) return null;
-      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
-      if (lockData.pid) {
-        process.kill(lockData.pid, 0);
-        return lockData.pid;
+      const content = fs.readFileSync(lockPath, 'utf-8');
+      const pidMatch = content.match(/pid=(\d+)/);
+      if (pidMatch) {
+        const pid = parseInt(pidMatch[1], 10);
+        process.kill(pid, 0);
+        this._clearPendingWatcher(projectPath, pid);
+        return pid;
       }
     } catch { /* not running */ }
     return null;

package/references/vscode-extension/dist/lib/locale.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const vscode = require('vscode');
+
+const EXTENSION_LOCALE_KEY = 'cursorGuard.locale';
+
+function normalizeLocale(locale) {
+  return locale === 'zh-CN' ? 'zh-CN' : 'en-US';
+}
+
+function detectLocale() {
+  return normalizeLocale(
+    (vscode.env.language || '').toLowerCase().startsWith('zh') ? 'zh-CN' : 'en-US'
+  );
+}
+
+function getLocale(storage) {
+  if (!storage || typeof storage.get !== 'function') return detectLocale();
+  return normalizeLocale(storage.get(EXTENSION_LOCALE_KEY) || detectLocale());
+}
+
+async function setLocale(storage, locale) {
+  const normalized = normalizeLocale(locale);
+  if (storage && typeof storage.update === 'function') {
+    await storage.update(EXTENSION_LOCALE_KEY, normalized);
+  }
+  return normalized;
+}
+
+module.exports = {
+  EXTENSION_LOCALE_KEY,
+  normalizeLocale,
+  detectLocale,
+  getLocale,
+  setLocale,
+};