cursor-guard 4.9.9 → 4.9.15

package/references/vscode-extension/lib/auto-setup.js

@@ -1,192 +1,201 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function detectIdeDir(vscode) {
-  const appName = (vscode.env.appName || '').toLowerCase();
-  const home = process.env.USERPROFILE || process.env.HOME || '';
-
-  const ideDirs = [];
-
-  if (appName.includes('cursor')) {
-    ideDirs.push('.cursor');
-  } else if (appName.includes('windsurf')) {
-    ideDirs.push('.windsurf');
-  } else if (appName.includes('trae')) {
-    ideDirs.push('.trae');
-  }
-
-  ideDirs.push('.cursor', '.windsurf', '.vscode');
-
-  const seen = new Set();
-  for (const dir of ideDirs) {
-    if (seen.has(dir)) continue;
-    seen.add(dir);
-    const full = path.join(home, dir);
-    if (fs.existsSync(full)) return { dirName: dir, homePath: full };
-  }
-
-  return { dirName: ideDirs[0], homePath: path.join(home, ideDirs[0]) };
-}
-
-function getExtensionRoot(context) {
-  return context.extensionPath;
-}
-
-function findBundledSkill(extRoot) {
-  const skillDir = path.join(extRoot, 'skill');
-  if (fs.existsSync(path.join(skillDir, 'SKILL.md'))) return skillDir;
-  const fromRefs = path.resolve(extRoot, '..', '..', 'SKILL.md');
-  if (fs.existsSync(fromRefs)) return path.resolve(extRoot, '..', '..');
-  return null;
-}
-
-async function autoSetup(context, vscode) {
-  const extRoot = getExtensionRoot(context);
-  const { dirName, homePath } = detectIdeDir(vscode);
-  const workspaceFolders = vscode.workspace.workspaceFolders;
-  const wsRoot = workspaceFolders?.[0]?.uri.fsPath;
-
-  const actions = [];
-
-  try { actions.push(...autoInstallSkill(extRoot, homePath, dirName)); } catch { /* non-critical */ }
-  try { actions.push(...autoRegisterMcp(extRoot, homePath, wsRoot)); } catch { /* non-critical */ }
-  if (wsRoot) {
-    try { actions.push(...autoCreateConfig(extRoot, wsRoot)); } catch { /* non-critical */ }
-  }
-
-  if (actions.length > 0) {
-    vscode.window.showInformationMessage(`Cursor Guard: auto-setup complete — ${actions.join(', ')}`);
-  }
-}
-
-function autoInstallSkill(extRoot, homePath, dirName) {
-  const actions = [];
-  const skillSrc = findBundledSkill(extRoot);
-  if (!skillSrc) return actions;
-
-  const skillTarget = path.join(homePath, 'skills', 'cursor-guard');
-  fs.mkdirSync(skillTarget, { recursive: true });
-
-  // ── Install/update SKILL.md and ROADMAP.md ──
-  const skillMdSrc = path.join(skillSrc, 'SKILL.md');
-  const skillMdTarget = path.join(skillTarget, 'SKILL.md');
-  if (fs.existsSync(skillMdSrc) && !fs.existsSync(skillMdTarget)) {
-    fs.copyFileSync(skillMdSrc, skillMdTarget);
-    actions.push('SKILL.md installed');
-  }
-
-  const roadmapSrc = path.join(skillSrc, 'ROADMAP.md');
-  const roadmapDst = path.join(skillTarget, 'ROADMAP.md');
-  if (fs.existsSync(roadmapSrc) && !fs.existsSync(roadmapDst)) {
-    fs.copyFileSync(roadmapSrc, roadmapDst);
-  }
-
-  // ── Ensure references/ junction exists (runs even for existing installations) ──
-  const refsTarget = path.join(skillTarget, 'references');
-  const refsIsJunction = _isSymlinkOrJunction(refsTarget);
-  const refsIsPlainDir = !refsIsJunction && fs.existsSync(refsTarget);
-  const refsMissingRuntime = refsIsPlainDir && !fs.existsSync(path.join(refsTarget, 'mcp'));
-
-  if (!fs.existsSync(refsTarget) || refsMissingRuntime) {
-    // Remove old plain directory if it only has docs (no runtime)
-    if (refsMissingRuntime) {
-      try { fs.rmSync(refsTarget, { recursive: true, force: true }); } catch { /* ok */ }
-    }
-    try {
-      fs.symlinkSync(extRoot, refsTarget, 'junction');
-      actions.push('references/ linked');
-    } catch {
-      fs.mkdirSync(refsTarget, { recursive: true });
-      _copyDocFiles(skillSrc, refsTarget);
-    }
-  }
-
-  // ── Ensure package.json exists ──
-  const pkgDst = path.join(skillTarget, 'package.json');
-  if (!fs.existsSync(pkgDst)) {
-    const pkgSrc = path.join(extRoot, '..', '..', 'package.json');
-    const guardVer = path.join(extRoot, 'guard-version.json');
-    if (fs.existsSync(pkgSrc)) {
-      fs.copyFileSync(pkgSrc, pkgDst);
-    } else if (fs.existsSync(guardVer)) {
-      fs.copyFileSync(guardVer, pkgDst);
-    }
-  }
-
-  return actions;
-}
-
-function _isSymlinkOrJunction(p) {
-  try {
-    const stat = fs.lstatSync(p);
-    return stat.isSymbolicLink();
-  } catch { return false; }
-}
-
-function _copyDocFiles(skillSrc, refsTarget) {
-  const docs = [
-    'config-reference.md', 'config-reference.zh-CN.md',
-    'recovery.md', 'cursor-guard.schema.json', 'cursor-guard.example.json',
-  ];
-  for (const f of docs) {
-    const src = path.join(skillSrc, f);
-    if (fs.existsSync(src)) fs.copyFileSync(src, path.join(refsTarget, f));
-  }
-}
-
-function autoRegisterMcp(extRoot, homePath, wsRoot) {
-  const actions = [];
-  const mcpServerPath = path.join(extRoot, 'mcp', 'server.js');
-  if (!fs.existsSync(mcpServerPath)) return actions;
-
-  const mcpJsonPaths = [
-    wsRoot ? path.join(wsRoot, '.cursor', 'mcp.json') : null,
-    wsRoot ? path.join(wsRoot, '.windsurf', 'mcp.json') : null,
-    path.join(homePath, 'mcp.json'),
-  ].filter(Boolean);
-
-  for (const mcpJsonPath of mcpJsonPaths) {
-    const dir = path.dirname(mcpJsonPath);
-    if (!fs.existsSync(dir)) continue;
-
-    let mcpConfig = { mcpServers: {} };
-    if (fs.existsSync(mcpJsonPath)) {
-      try { mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8')); } catch { continue; }
-    }
-
-    if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
-    if (mcpConfig.mcpServers['cursor-guard']) return actions;
-
-    mcpConfig.mcpServers['cursor-guard'] = {
-      command: 'node',
-      args: [mcpServerPath.replace(/\\/g, '/')],
-    };
-
-    fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
-    actions.push('MCP registered');
-    return actions;
-  }
-
-  return actions;
-}
-
-function autoCreateConfig(extRoot, wsRoot) {
-  const actions = [];
-  const configTarget = path.join(wsRoot, '.cursor-guard.json');
-  if (fs.existsSync(configTarget)) return actions;
-
-  const exampleSrc = path.join(extRoot, 'skill', 'cursor-guard.example.json');
-  const exampleFromRefs = path.join(extRoot, '..', 'cursor-guard.example.json');
-  const src = fs.existsSync(exampleSrc) ? exampleSrc : fs.existsSync(exampleFromRefs) ? exampleFromRefs : null;
-
-  if (src) {
-    fs.copyFileSync(src, configTarget);
-    actions.push('.cursor-guard.json created');
-  }
-
-  return actions;
-}
-
-module.exports = { autoSetup, detectIdeDir };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function detectIdeDir(vscode) {
+  const appName = (vscode.env.appName || '').toLowerCase();
+  const home = process.env.USERPROFILE || process.env.HOME || '';
+
+  const ideDirs = [];
+
+  if (appName.includes('cursor')) {
+    ideDirs.push('.cursor');
+  } else if (appName.includes('windsurf')) {
+    ideDirs.push('.windsurf');
+  } else if (appName.includes('trae')) {
+    ideDirs.push('.trae');
+  }
+
+  ideDirs.push('.cursor', '.windsurf', '.vscode');
+
+  const seen = new Set();
+  for (const dir of ideDirs) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    const full = path.join(home, dir);
+    if (fs.existsSync(full)) return { dirName: dir, homePath: full };
+  }
+
+  return { dirName: ideDirs[0], homePath: path.join(home, ideDirs[0]) };
+}
+
+function getExtensionRoot(context) {
+  return context.extensionPath;
+}
+
+function findBundledSkill(extRoot) {
+  const skillDir = path.join(extRoot, 'skill');
+  if (fs.existsSync(path.join(skillDir, 'SKILL.md'))) return skillDir;
+  const fromRefs = path.resolve(extRoot, '..', '..', 'SKILL.md');
+  if (fs.existsSync(fromRefs)) return path.resolve(extRoot, '..', '..');
+  return null;
+}
+
+async function autoSetup(context, vscode) {
+  const extRoot = getExtensionRoot(context);
+  const { dirName, homePath } = detectIdeDir(vscode);
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  const wsRoot = workspaceFolders?.[0]?.uri.fsPath;
+
+  const actions = [];
+  let skillPath = null;
+
+  try {
+    const skillResult = installAgentSkill(extRoot, homePath, dirName);
+    actions.push(...skillResult.actions);
+    skillPath = skillResult.skillPath;
+  } catch { /* non-critical */ }
+  try { actions.push(...autoRegisterMcp(extRoot, homePath, wsRoot)); } catch { /* non-critical */ }
+  if (wsRoot) {
+    try { actions.push(...autoCreateConfig(extRoot, wsRoot)); } catch { /* non-critical */ }
+  }
+
+  return { actions, skillPath };
+}
+
+/** Copy / link bundled Agent Skill into ~/.cursor/skills/cursor-guard (or IDE-specific home). */
+function installAgentSkill(extRoot, homePath, dirName) {
+  const actions = [];
+  const skillSrc = findBundledSkill(extRoot);
+  if (!skillSrc) return { actions, skillPath: null };
+
+  const skillTarget = path.join(homePath, 'skills', 'cursor-guard');
+  fs.mkdirSync(skillTarget, { recursive: true });
+
+  // ── Install/update SKILL.md and ROADMAP.md ──
+  const skillMdSrc = path.join(skillSrc, 'SKILL.md');
+  const skillMdTarget = path.join(skillTarget, 'SKILL.md');
+  if (fs.existsSync(skillMdSrc) && !fs.existsSync(skillMdTarget)) {
+    fs.copyFileSync(skillMdSrc, skillMdTarget);
+    actions.push('SKILL.md installed');
+  }
+
+  const roadmapSrc = path.join(skillSrc, 'ROADMAP.md');
+  const roadmapDst = path.join(skillTarget, 'ROADMAP.md');
+  if (fs.existsSync(roadmapSrc) && !fs.existsSync(roadmapDst)) {
+    fs.copyFileSync(roadmapSrc, roadmapDst);
+  }
+
+  // ── Ensure references/ junction exists (runs even for existing installations) ──
+  const refsTarget = path.join(skillTarget, 'references');
+  const refsIsJunction = _isSymlinkOrJunction(refsTarget);
+  const refsIsPlainDir = !refsIsJunction && fs.existsSync(refsTarget);
+  const refsMissingRuntime = refsIsPlainDir && !fs.existsSync(path.join(refsTarget, 'mcp'));
+
+  if (!fs.existsSync(refsTarget) || refsMissingRuntime) {
+    // Remove old plain directory if it only has docs (no runtime)
+    if (refsMissingRuntime) {
+      try { fs.rmSync(refsTarget, { recursive: true, force: true }); } catch { /* ok */ }
+    }
+    try {
+      fs.symlinkSync(extRoot, refsTarget, 'junction');
+      actions.push('references/ linked');
+    } catch {
+      fs.mkdirSync(refsTarget, { recursive: true });
+      _copyDocFiles(skillSrc, refsTarget);
+    }
+  }
+
+  // ── Ensure package.json exists ──
+  const pkgDst = path.join(skillTarget, 'package.json');
+  if (!fs.existsSync(pkgDst)) {
+    const pkgSrc = path.join(extRoot, '..', '..', 'package.json');
+    const guardVer = path.join(extRoot, 'guard-version.json');
+    if (fs.existsSync(pkgSrc)) {
+      fs.copyFileSync(pkgSrc, pkgDst);
+    } else if (fs.existsSync(guardVer)) {
+      fs.copyFileSync(guardVer, pkgDst);
+    }
+  }
+
+  return { actions, skillPath: skillTarget };
+}
+
+function _isSymlinkOrJunction(p) {
+  try {
+    const stat = fs.lstatSync(p);
+    return stat.isSymbolicLink();
+  } catch { return false; }
+}
+
+function _copyDocFiles(skillSrc, refsTarget) {
+  const docs = [
+    'config-reference.md', 'config-reference.zh-CN.md',
+    'recovery.md', 'cursor-guard.schema.json', 'cursor-guard.example.json',
+  ];
+  for (const f of docs) {
+    const src = path.join(skillSrc, f);
+    if (fs.existsSync(src)) fs.copyFileSync(src, path.join(refsTarget, f));
+  }
+}
+
+function autoRegisterMcp(extRoot, homePath, wsRoot) {
+  const actions = [];
+  const mcpServerPath = path.join(extRoot, 'mcp', 'server.js');
+  if (!fs.existsSync(mcpServerPath)) return actions;
+
+  const mcpJsonPaths = [
+    wsRoot ? path.join(wsRoot, '.cursor', 'mcp.json') : null,
+    wsRoot ? path.join(wsRoot, '.windsurf', 'mcp.json') : null,
+    path.join(homePath, 'mcp.json'),
+  ].filter(Boolean);
+
+  for (const mcpJsonPath of mcpJsonPaths) {
+    const dir = path.dirname(mcpJsonPath);
+    if (!fs.existsSync(dir)) continue;
+
+    let mcpConfig = { mcpServers: {} };
+    if (fs.existsSync(mcpJsonPath)) {
+      try { mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8')); } catch { continue; }
+    }
+
+    if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    if (mcpConfig.mcpServers['cursor-guard']) return actions;
+
+    mcpConfig.mcpServers['cursor-guard'] = {
+      command: 'node',
+      args: [mcpServerPath.replace(/\\/g, '/')],
+    };
+
+    fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+    actions.push('MCP registered');
+    return actions;
+  }
+
+  return actions;
+}
+
+function autoCreateConfig(extRoot, wsRoot) {
+  const actions = [];
+  const configTarget = path.join(wsRoot, '.cursor-guard.json');
+  if (fs.existsSync(configTarget)) return actions;
+
+  const exampleSrc = path.join(extRoot, 'skill', 'cursor-guard.example.json');
+  const exampleFromRefs = path.join(extRoot, '..', 'cursor-guard.example.json');
+  const src = fs.existsSync(exampleSrc) ? exampleSrc : fs.existsSync(exampleFromRefs) ? exampleFromRefs : null;
+
+  if (src) {
+    fs.copyFileSync(src, configTarget);
+    actions.push('.cursor-guard.json created');
+  }
+
+  return actions;
+}
+
+module.exports = {
+  autoSetup,
+  detectIdeDir,
+  installAgentSkill,
+  getExtensionRoot,
+};

package/references/vscode-extension/lib/poller.js

@@ -1,8 +1,23 @@
 'use strict';
 
-const vscode = require('vscode');
+const fs = require('fs');
+const path = require('path');
+const { guardPath } = require('./paths');
 
-const HEARTBEAT_INTERVAL = 30000;
+/** Safety net if fs.watch misses (platform limits); primary updates are filesystem events. */
+const FALLBACK_POLL_MS = 180000;
+
+function tryWatchDirRecursive(dir, cb) {
+  try {
+    return fs.watch(dir, { recursive: true }, cb);
+  } catch {
+    try {
+      return fs.watch(dir, cb);
+    } catch {
+      return null;
+    }
+  }
+}
 
 class Poller {
   constructor(dashMgr) {
@@ -11,6 +26,12 @@ class Poller {
     this._listeners = [];
     this._data = new Map();
     this._pollRunning = false;
+    this._pollAgainAfter = false;
+    this._pollWaiters = [];
+    this._fsWatchers = [];
+    this._watchedRegistryKey = '';
+    this._fsDebounceTimer = null;
+    this._reattachTimer = null;
   }
 
   get data() { return this._data; }
@@ -26,10 +47,107 @@ class Poller {
     }
   }
 
+  _teardownFsWatchers() {
+    if (this._reattachTimer) {
+      clearTimeout(this._reattachTimer);
+      this._reattachTimer = null;
+    }
+    if (this._fsDebounceTimer) {
+      clearTimeout(this._fsDebounceTimer);
+      this._fsDebounceTimer = null;
+    }
+    for (const w of this._fsWatchers) {
+      try { w.close(); } catch { /* ignore */ }
+    }
+    this._fsWatchers = [];
+  }
+
+  _scheduleFsRefresh() {
+    if (this._fsDebounceTimer) clearTimeout(this._fsDebounceTimer);
+    this._fsDebounceTimer = setTimeout(() => {
+      this._fsDebounceTimer = null;
+      void this.forceRefresh();
+    }, 400);
+  }
+
+  _syncFileWatchers() {
+    const reg = this._dashMgr?.registry;
+    if (!reg) return;
+    const key = [...reg.entries()].map(([k, v]) => `${k}:${v._path}`).sort().join('|');
+    if (key === this._watchedRegistryKey) return;
+    this._watchedRegistryKey = key;
+
+    this._teardownFsWatchers();
+
+    let utils;
+    try {
+      utils = require(guardPath('lib', 'utils'));
+    } catch {
+      return;
+    }
+    const { isGitRepo, gitDir: getGitDir } = utils;
+
+    for (const proj of reg.values()) {
+      const pp = proj._path;
+      const pid = proj.id;
+
+      if (isGitRepo(pp)) {
+        const gDir = getGitDir(pp);
+        if (gDir && fs.existsSync(gDir)) {
+          try {
+            const w = fs.watch(gDir, (ev, fname) => {
+              if (fname === 'cursor-guard-alert.json' || fname === 'cursor-guard.lock') {
+                this._scheduleFsRefresh();
+              }
+            });
+            this._fsWatchers.push(w);
+          } catch { /* ignore */ }
+
+          const refsDir = path.join(gDir, 'refs');
+          if (fs.existsSync(refsDir)) {
+            try {
+              const w = fs.watch(refsDir, (ev, fname) => {
+                if (!fname) return;
+                if (fname === 'guard' || fname.startsWith('guard')) {
+                  this._scheduleFsRefresh();
+                  if (!this._reattachTimer) {
+                    this._reattachTimer = setTimeout(() => {
+                      this._reattachTimer = null;
+                      this._watchedRegistryKey = '';
+                      this._syncFileWatchers();
+                    }, 600);
+                  }
+                }
+              });
+              this._fsWatchers.push(w);
+            } catch { /* ignore */ }
+          }
+
+          const guardDir = path.join(gDir, 'refs', 'guard');
+          if (fs.existsSync(guardDir)) {
+            const w = tryWatchDirRecursive(guardDir, () => this._scheduleFsRefresh());
+            if (w) this._fsWatchers.push(w);
+            const preRestoreDir = path.join(guardDir, 'pre-restore');
+            if (fs.existsSync(preRestoreDir)) {
+              const w2 = tryWatchDirRecursive(preRestoreDir, () => this._scheduleFsRefresh());
+              if (w2) this._fsWatchers.push(w2);
+            }
+          }
+        }
+      }
+
+      const backupDir = path.join(pp, '.cursor-guard-backup');
+      if (fs.existsSync(backupDir)) {
+        const w = tryWatchDirRecursive(backupDir, () => this._scheduleFsRefresh());
+        if (w) this._fsWatchers.push(w);
+      }
+    }
+  }
+
   start() {
     if (this._timer) return;
-    this._poll();
-    this._timer = setInterval(() => this._poll(), HEARTBEAT_INTERVAL);
+    void this._poll();
+    this._timer = setInterval(() => void this._poll(), FALLBACK_POLL_MS);
   }
 
   stop() {
@@ -37,33 +155,55 @@ class Poller {
   }
 
   async _poll() {
-    if (this._pollRunning) return;
+    if (this._pollRunning) {
+      this._pollAgainAfter = true;
+      return;
+    }
     this._pollRunning = true;
     try {
-      if (!this._dashMgr.running) return;
-      const projects = await this._dashMgr.getProjects();
-      if (!Array.isArray(projects)) return;
-      for (const p of projects) {
-        const fullData = await this._dashMgr.getFullPageData(p.id);
-        this._data.set(p.id, {
-          ...p,
-          dashboard: fullData?.dashboard || null,
-          backups: fullData?.backups || [],
-          scope: fullData?.scope || null,
-          doctor: fullData?.doctor || null,
-        });
-      }
-      this._emit();
+      do {
+        this._pollAgainAfter = false;
+        if (!this._dashMgr.running) break;
+        const projects = await this._dashMgr.getProjects();
+        if (!Array.isArray(projects)) break;
+        for (const p of projects) {
+          const fullData = await this._dashMgr.getFullPageData(p.id);
+          this._data.set(p.id, {
+            ...p,
+            dashboard: fullData?.dashboard || null,
+            backups: fullData?.backups || [],
+            scope: fullData?.scope || null,
+            doctor: fullData?.doctor || null,
+          });
+        }
+        this._emit();
+      } while (this._pollAgainAfter);
     } catch { /* non-critical */ }
-    finally { this._pollRunning = false; }
+    finally {
+      this._pollRunning = false;
+      const waiters = this._pollWaiters.splice(0);
+      for (const fn of waiters) {
+        try { fn(); } catch { /* ignore */ }
+      }
+      try {
+        this._syncFileWatchers();
+      } catch { /* ignore */ }
+    }
   }
 
   async forceRefresh() {
-    await this._poll();
+    return new Promise(resolve => {
+      this._pollWaiters.push(resolve);
+      this._pollAgainAfter = true;
+      if (!this._pollRunning) {
+        void this._poll();
+      }
+    });
   }
 
   dispose() {
     this.stop();
+    this._teardownFsWatchers();
     this._listeners = [];
   }
 }

package/references/vscode-extension/lib/sidebar-webview.js

@@ -2,6 +2,7 @@
 
 const vscode = require('vscode');
 const { getLocale, setLocale } = require('./locale');
+const { guardPath } = require('./paths');
 
 class SidebarDashboardProvider {
   constructor(poller, context) {
@@ -41,6 +42,19 @@ class SidebarDashboardProvider {
         this._postLocale();
       }
       if (msg.cmd === 'exec') vscode.commands.executeCommand(msg.command);
+      if (msg.cmd === 'clearAlert' && msg.projectId) {
+        (async () => {
+          try {
+            const reg = this._poller._dashMgr?.registry;
+            const entry = reg?.get(msg.projectId);
+            if (entry?._path) {
+              const { clearAlert } = require(guardPath('lib', 'core', 'anomaly'));
+              clearAlert(entry._path);
+              await this._poller.forceRefresh();
+            }
+          } catch { /* ignore */ }
+        })();
+      }
     });
 
     webviewView.onDidChangeVisibility(() => {
@@ -1058,6 +1072,7 @@ const I18N = {
     'actions.openDashboard': '打开看板',
     'actions.restore': '恢复',
     'actions.viewDetails': '查看详情',
+    'actions.dismissAlert': '忽略告警',
     'actions.snapshot': '立即快照',
     'actions.watcherOn': '停止 Watcher',
     'actions.watcherOff': '启动 Watcher',
@@ -1290,6 +1305,13 @@ function render(projects) {
       vscode.postMessage({ cmd: 'exec', command: btn.dataset.cmd });
     });
   });
+
+  root.querySelectorAll('[data-dismiss-alert]').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const pid = btn.getAttribute('data-dismiss-alert');
+      if (pid) vscode.postMessage({ cmd: 'clearAlert', projectId: pid });
+    });
+  });
 }
 
 function renderProject(dashboard, projectId) {