cursor-guard 4.6.2 → 4.7.1

package/README.md

@@ -25,6 +25,10 @@ When Cursor's AI agent edits your files, there's a risk of accidental overwrites
 - **Proactive change-velocity alerts (V4)** — Auto-detects abnormal file change patterns and raises risk warnings
 - **Backup health dashboard (V4)** — One-call comprehensive view: strategy, counts, disk usage, protection scope, health status
 - **Web dashboard (V4.2)** — Local read-only web UI at `http://127.0.0.1:3120` — see health, backups, restore points, diagnostics, protection scope at a glance. Dual-language (zh-CN / en-US), auto-refresh every 15s, multi-project support
+- **IDE extension (V4.7)** — Full dashboard embedded in VSCode/Cursor/Windsurf as a WebView tab + status bar alert indicator + sidebar project tree. No browser needed
+- **One-click hot restart (V4.5.8)** — Dashboard detects new versions and offers in-place server restart without losing state
+- **Shadow incremental hard links (V4.5.4)** — Unchanged files are hard-linked to save disk space and I/O
+- **Strong protection mode (V4.5.4)** — `always_watch: true` auto-starts watcher with MCP server, ensuring zero protection gaps
 
 ---
 
@@ -124,6 +128,11 @@ After installation, your directory structure should look like this:
     │       └── app.js
     ├── mcp/
     │   └── server.js                   # MCP Server (9 tools)
+    ├── vscode-extension/               # IDE Extension (V4.7)
+    │   ├── extension.js                # Extension entry point
+    │   ├── package.json                # Extension manifest
+    │   ├── lib/                        # Modules (dashboard-manager, webview, status-bar, tree-view, poller)
+    │   └── media/                      # Icons (SVG + PNG)
     ├── bin/
     │   ├── cursor-guard-backup.js      # CLI: npx cursor-guard-backup
     │   ├── cursor-guard-doctor.js      # CLI: npx cursor-guard-doctor
@@ -274,7 +283,7 @@ npx cursor-guard-dashboard --path /my/project --port 8080
 node references\dashboard\server.js --path "D:\MyProject"
 ```
 
-Then open `http://127.0.0.1:3120` in your browser.
+Then open `http://127.0.0.1:3120` in your browser. Or use the **IDE Extension** (see below) to embed the dashboard directly in your editor.
 
 Features:
 
@@ -287,6 +296,29 @@ Features:
 - **Security** — binds to `127.0.0.1` only (not exposed to LAN), API uses project IDs instead of raw file paths, static file serving restricted to `public/` directory
 - **Zero extra dependencies** — uses Node.js built-in `http` module + existing cursor-guard core modules
 
+### IDE Extension (VSCode / Cursor)
+
+Embed the full dashboard directly inside your IDE — no browser needed.
+
+The extension is located at `references/vscode-extension/`. To install:
+
+```bash
+# From the cursor-guard skill directory
+cd references/vscode-extension
+# Install as a development extension in your IDE
+code --install-extension .
+```
+
+Features:
+
+- **WebView Dashboard** — full dashboard embedded as an editor tab, identical to the browser version
+- **Status Bar Indicator** — shows `Guard: OK` (green) or `Guard: 22 files!` (yellow) in real-time
+- **Sidebar TreeView** — activity bar icon with project list, watcher status, backup stats, alerts, health
+- **Command Palette** — `Cursor Guard: Open Dashboard`, `Snapshot Now`, `Start Watcher`, `Refresh`
+- **Auto-activation** — detects `.cursor-guard.json` in workspace, starts dashboard server automatically
+- **Multi-project** — hot-loads all workspace folders with `.cursor-guard.json`
+- **Compatible** — works with VSCode ^1.74.0, Cursor, Windsurf, and all VSCode-based IDEs
+
 ---
 
 ## Recovery
@@ -365,6 +397,7 @@ The skill activates on these signals:
 | `references/bin/cursor-guard-doctor.js` | CLI entry: `npx cursor-guard-doctor` |
 | `references/dashboard/server.js` | Dashboard HTTP server + REST API |
 | `references/dashboard/public/` | Dashboard web UI (index.html, style.css, app.js) |
+| `references/vscode-extension/` | IDE Extension: WebView dashboard, status bar, sidebar tree, commands |
 | `references/auto-backup.ps1` / `.sh` | Thin wrappers (Windows / macOS+Linux) |
 | `references/guard-doctor.ps1` / `.sh` | Thin wrappers (Windows / macOS+Linux) |
 | `references/recovery.md` | Recovery command templates |
@@ -377,6 +410,33 @@ The skill activates on these signals:
 
 ## Changelog
 
+### v4.7.0 — IDE Extension
+
+- **Feature**: VSCode/Cursor/Windsurf extension — full dashboard as WebView tab, status bar alert indicator, sidebar TreeView with project status, Command Palette integration
+- **Feature**: Auto-activation on `.cursor-guard.json` detection, dashboard server runs in extension host process (zero subprocess overhead)
+- **Adapt**: `fetchJson()` supports `__GUARD_BASE_URL__` for WebView; `copyText()` bridges to `vscode.env.clipboard` when in IDE
+
+### v4.6.x — Alert UX Overhaul
+
+- **Fix**: Alert countdown now updates every second (was only on 15s page refresh)
+- **Fix**: Alert file details modal now shows per-file "Copy Restore Command" buttons
+- **Fix**: Backup stale threshold changed to `max(interval*10, 300)s` (min 5 min); only checks when watcher is running
+- **Feature**: Alert history always accessible (both active and no-alert states), persisted in `localStorage`
+- **Feature**: Alert history as modal dialog with nested file detail drill-down
+
+### v4.5.x — Protection Hardening
+
+- **Fix**: Shadow hard-link ordering bug (previous snapshot was always empty directory)
+- **Fix**: `changedFiles` now filters ignored paths from git diff output
+- **Feature**: Alert structured file list — per-file path, action, +/- lines, sortable tables
+- **Feature**: Shadow incremental hard links — unchanged files linked to previous snapshot, saving disk space
+- **Feature**: `always_watch: true` config — watcher auto-starts with MCP server, zero protection gaps
+- **Feature**: Dashboard server singleton — multiple projects share one port, hot-add new projects
+- **Feature**: Dashboard version detection + one-click hot restart (`/api/restart` endpoint)
+- **Feature**: File detail modal with per-file restore command copy buttons
+- **Feature**: `cursor-guard-init` auto-creates `.cursor-guard.json`; `backup_interval_seconds` alias supported
+- **License**: Changed from MIT to BSL 1.1 (source available, commercial use requires author authorization)
+
 ### v4.4.0 — V4 Final
 
 - **Fix**: First snapshot now generates "Added N: file1, file2, ..." summary instead of blank — previously the very first backup had no summary because there was no parent tree to diff against
@@ -466,6 +526,16 @@ The skill activates on these signals:
 
 ---
 
+## Support / Donate
+
+This is an independent open-source project maintained by a solo developer. If Cursor Guard has saved your code or your time, consider buying me a coffee :)
+
+| WeChat Pay | Alipay |
+|:---:|:---:|
+| <img src="media/wechat-pay.png" alt="WeChat Pay" width="200"> | <img src="media/alipay.jpg" alt="Alipay" width="200"> |
+
+---
+
 ## License
 
-MIT
+[BSL 1.1 (Business Source License)](LICENSE) — Source code is freely available for viewing, modification, and non-commercial use. Commercial use requires authorization from the author. Auto-converts to Apache 2.0 on 2056-03-22.

package/README.zh-CN.md

@@ -25,6 +25,10 @@
 - **主动变更频率告警（V4）** — 自动检测异常文件变更模式并发出风险预警
 - **备份健康看板（V4）** — 一次调用全面查看：策略、数量、磁盘占用、保护范围、健康状态
 - **Web 仪表盘（V4.2）** — 本地只读 Web 页面 `http://127.0.0.1:3120`——健康状态、备份、恢复点、诊断、保护范围一目了然。中英双语、每 15 秒自动刷新、支持多项目监控
+- **IDE 扩展（V4.7）** — 完整仪表盘嵌入 VSCode/Cursor/Windsurf，WebView 标签页 + 状态栏告警指示器 + 侧边栏项目树。无需打开浏览器
+- **一键热重启（V4.5.8）** — 仪表盘检测到新版本时可原地重启服务，不丢失状态
+- **Shadow 增量硬链接（V4.5.4）** — 未变更文件硬链接到上次快照，节省磁盘空间和 I/O
+- **强保护模式（V4.5.4）** — `always_watch: true` 让 watcher 随 MCP server 自动启动，确保零保护缺口
 
 ---
 
@@ -124,6 +128,11 @@ git clone https://github.com/zhangqiang8vipp/cursor-guard.git .cursor/skills/cur
     │       └── app.js
     ├── mcp/
     │   └── server.js                   # MCP Server（9 个工具）
+    ├── vscode-extension/               # IDE 扩展（V4.7）
+    │   ├── extension.js                # 扩展入口
+    │   ├── package.json                # 扩展清单
+    │   ├── lib/                        # 模块（dashboard-manager、webview、status-bar、tree-view、poller）
+    │   └── media/                      # 图标（SVG + PNG）
     ├── bin/
     │   ├── cursor-guard-backup.js      # CLI：npx cursor-guard-backup
     │   ├── cursor-guard-doctor.js      # CLI：npx cursor-guard-doctor
@@ -274,7 +283,7 @@ npx cursor-guard-dashboard --path /my/project --port 8080
 node references\dashboard\server.js --path "D:\MyProject"
 ```
 
-然后在浏览器打开 `http://127.0.0.1:3120`。
+然后在浏览器打开 `http://127.0.0.1:3120`。也可以使用 **IDE 扩展**（见下方）将仪表盘直接嵌入编辑器。
 
 特性：
 
@@ -287,6 +296,29 @@ node references\dashboard\server.js --path "D:\MyProject"
 - **安全性** — 仅绑定 `127.0.0.1`（不暴露到局域网）、API 使用项目 ID 而非原始路径、静态文件服务严格限制在 `public/` 目录
 - **零额外依赖** — 使用 Node.js 内置 `http` 模块 + cursor-guard 已有核心模块
 
+### IDE 扩展（VSCode / Cursor）
+
+将完整仪表盘直接嵌入 IDE 内部，无需打开浏览器。
+
+扩展位于 `references/vscode-extension/`。安装方式：
+
+```bash
+# 从 cursor-guard skill 目录
+cd references/vscode-extension
+# 作为开发扩展安装到 IDE
+code --install-extension .
+```
+
+功能：
+
+- **WebView 仪表盘** — 完整仪表盘作为编辑器标签页嵌入，与浏览器版本完全一致
+- **状态栏指示器** — 实时显示 `Guard: OK`（绿色）或 `Guard: 22 files!`（黄色告警）
+- **侧边栏 TreeView** — Activity Bar 图标，树形展示项目列表、Watcher 状态、备份统计、告警、健康评估
+- **命令面板** — `Cursor Guard: Open Dashboard`、`Snapshot Now`、`Start Watcher`、`Refresh`
+- **自动激活** — 检测到工作区有 `.cursor-guard.json` 时自动启动 Dashboard 服务
+- **多项目** — 热加载所有包含 `.cursor-guard.json` 的工作区文件夹
+- **兼容性** — 支持 VSCode ^1.74.0、Cursor、Windsurf 及所有基于 VSCode 的 IDE
+
 ---
 
 ## 恢复
@@ -365,6 +397,7 @@ node references\dashboard\server.js --path "D:\MyProject"
 | `references/bin/cursor-guard-doctor.js` | CLI 入口：`npx cursor-guard-doctor` |
 | `references/dashboard/server.js` | 仪表盘 HTTP 服务 + REST API |
 | `references/dashboard/public/` | 仪表盘 Web UI（index.html、style.css、app.js） |
+| `references/vscode-extension/` | IDE 扩展：WebView 仪表盘、状态栏、侧边栏树、命令面板 |
 | `references/auto-backup.ps1` / `.sh` | 薄封装（Windows / macOS+Linux） |
 | `references/guard-doctor.ps1` / `.sh` | 薄封装（Windows / macOS+Linux） |
 | `references/recovery.md` | 恢复命令模板 |
@@ -377,6 +410,33 @@ node references\dashboard\server.js --path "D:\MyProject"
 
 ## 更新日志
 
+### v4.7.0 — IDE 扩展
+
+- **功能**：VSCode/Cursor/Windsurf 扩展 — 完整仪表盘作为 WebView 标签页嵌入，状态栏告警指示器，侧边栏 TreeView 项目状态，命令面板集成
+- **功能**：检测到 `.cursor-guard.json` 自动激活，Dashboard 服务在扩展宿主进程内运行（零额外进程开销）
+- **适配**：`fetchJson()` 支持 `__GUARD_BASE_URL__` 用于 WebView；`copyText()` 在 IDE 中通过 `postMessage` 桥接到 `vscode.env.clipboard`
+
+### v4.6.x — 告警 UX 大优化
+
+- **修复**：告警倒计时现在每秒更新（之前仅在 15 秒页面刷新时更新）
+- **修复**：告警文件详情弹窗支持每文件「复制恢复命令」按钮
+- **修复**：备份过时阈值改为 `max(interval*10, 300)` 秒（至少 5 分钟）；仅在 watcher 运行时检查
+- **功能**：告警历史始终可访问（无论是否有活跃告警），使用 `localStorage` 持久化
+- **功能**：告警历史作为弹窗展示，支持嵌套查看文件详情
+
+### v4.5.x — 保护加固
+
+- **修复**：Shadow 硬链接顺序 bug（上次快照总是空目录）
+- **修复**：`changedFiles` 现在过滤忽略路径
+- **功能**：告警结构化文件列表 — 每文件路径、操作、+/- 行数，支持排序
+- **功能**：Shadow 增量硬链接 — 未变更文件链接到上次快照，节省磁盘空间
+- **功能**：`always_watch: true` 配置 — watcher 随 MCP server 自动启动，零保护缺口
+- **功能**：Dashboard 服务单例 — 多项目共享一个端口，热加载新项目
+- **功能**：Dashboard 版本检测 + 一键热重启（`/api/restart` 端点）
+- **功能**：文件详情弹窗 + 每文件恢复命令复制按钮
+- **功能**：`cursor-guard-init` 自动创建 `.cursor-guard.json`；支持 `backup_interval_seconds` 别名
+- **许可证**：从 MIT 变更为 BSL 1.1（源码可见，商业使用需作者授权）
+
 ### v4.4.0 — V4 收官版
 
 - **修复**：首次快照现在会生成 "Added N: file1, file2, ..." 摘要，而不是空白——之前第一次备份因为没有 parent tree 对比所以 summary 始终为空
@@ -466,6 +526,16 @@ node references\dashboard\server.js --path "D:\MyProject"
 
 ---
 
+## 支持 / 捐赠
+
+这是一个独立开发者维护的开源项目。如果 Cursor Guard 拯救过你的代码或节省了你的时间，欢迎请我喝杯咖啡 :)
+
+| 微信支付 | 支付宝 |
+|:---:|:---:|
+| <img src="media/wechat-pay.png" alt="微信支付" width="200"> | <img src="media/alipay.jpg" alt="支付宝" width="200"> |
+
+---
+
 ## 许可证
 
-MIT
+[BSL 1.1（商业源代码许可证）](LICENSE) — 源代码自由查看、修改和非商业使用。商业使用需获得作者授权。2056-03-22 之后自动转为 Apache 2.0。

package/ROADMAP.md

@@ -3,8 +3,8 @@
 > 本文档描述 cursor-guard 从 V2 到 V7 的长期演进方向。
 > 每一代向下兼容，低版本功能永远不废弃。
 >
-> **当前版本**：`V4.6.1`  
-> **文档状态**：`V2` ~ `V4.6.1` 已完成交付（含 V5 intent/audit 基础），`V5` 主体规划中
+> **当前版本**：`V4.7.1`  
+> **文档状态**：`V2` ~ `V4.7.1` 已完成交付（含 V5 intent/audit 基础），`V5` 主体规划中
 
 ## 阅读导航
 
@@ -734,14 +734,29 @@ V4 经过 4 轮系统性代码审查，修复了以下关键问题：
 }
 ```
 
-### V4.7 规划：IDE 集成（VSCode/Cursor Extension）
+### V4.7.1：IDE 插件 Bug 修复 + UX 增强 ✅
 
-| 项目 | 说明 |
+| 修复/增强 | 说明 |
+|----------|------|
+| **P1 Bug 修复** | `snapshotNow` 中 `loadConfig` 返回 `{cfg, loaded, error, warnings}`，但代码直接传了整个对象。修复为解构 `const { cfg } = loadConfig()` |
+| **WebView CSP** | WebView 缺少 Content-Security-Policy meta 标签，导致 `fetch` 请求被浏览器安全策略阻止（failed to fetch）。添加 CSP 允许 `connect-src` 到 Dashboard Server |
+| **一键启动/停止 Watcher** | `Start Watcher` / `Stop Watcher` 命令从提示文字改为实际 `spawn` 子进程启动和 `SIGTERM` 停止 |
+| **TreeView 彩色化** | 所有图标使用 `ThemeColor`（绿色=正常、红色=告警/停止、蓝色=备份、紫色=统计）。项目节点根据状态显示 Protected/Unprotected/ALERT。新增 Quick Actions 折叠区（Open Dashboard / Snapshot Now / Start/Stop Watcher / Refresh） |
+| **StatusBar 增强** | Watcher 未运行时显示 `$(eye-closed) Guard: Unprotected`；告警时图标动画 `$(bell~spin)` |
+
+### V4.7.0：IDE 集成（VSCode/Cursor Extension） ✅
+
+| 组件 | 说明 |
 |------|------|
-| 定位 | 将 Dashboard 从浏览器迁移到 IDE 内置 WebView，减少上下文切换 |
-| 实现方式 | VSCode Extension + WebView Panel，复用现有 `dashboard/public/` 前端代码 |
-| 核心能力 | IDE 侧边栏入口、状态栏告警指示器、WebView 内嵌 Dashboard、一键快照按钮 |
-| 状态 | 🔮 规划中 |
+| `extension.js` | 扩展入口。自动检测 `.cursor-guard.json` 激活，启动内嵌 Dashboard Server，注册所有命令和视图 |
+| `dashboard-manager.js` | 复用现有 `dashboard/server.js` 单例模式，在扩展宿主进程内直接 require，零额外开销。支持多 workspace folder 热加载 |
+| `webview-provider.js` | WebView Panel 管理。加载 `dashboard/public/` 前端，通过 `asWebviewUri()` 转换资源路径，注入 `__GUARD_TOKEN__` + `__GUARD_BASE_URL__` + `__IN_VSCODE__` |
+| `status-bar.js` | 状态栏告警指示器。正常时显示 `$(shield) Guard: OK`，告警时黄色背景 `$(warning) Guard: 22 files!`，点击打开 Dashboard |
+| `tree-view.js` | Activity Bar 侧边栏。树形展示项目列表，每个项目下显示 Watcher 状态、最近备份时间、备份统计、活跃告警、健康评估 |
+| `poller.js` | 后台每 5 秒轮询 `/api/page-data`，驱动状态栏和 TreeView 实时更新 |
+| `app.js` 适配 | `fetchJson` 支持 `window.__GUARD_BASE_URL__` 前缀（兼容浏览器和 WebView）；`copyText` 在 VSCode 中通过 `postMessage` 桥接到 `vscode.env.clipboard` |
+| 命令面板 | `Open Dashboard` / `Snapshot Now` / `Start/Stop Watcher` / `Refresh` |
+| 兼容性 | VSCode ^1.74.0，覆盖 Cursor、Windsurf 等所有 VSCode 衍生 IDE |
 
 ### V4 不做的事
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-guard",
-  "version": "4.6.2",
+  "version": "4.7.1",
   "description": "Protects code from accidental AI overwrite or deletion in Cursor IDE — mandatory pre-write snapshots, review-before-apply, local Git safety net, and deterministic recovery. | 保护代码免受 Cursor AI 代理意外覆写或删除——强制写前快照、预览再执行、本地 Git 安全网、确定性恢复。",
   "keywords": [
     "cursor",
@@ -50,6 +50,8 @@
     "references/lib/core/",
     "references/mcp/",
     "references/dashboard/",
+    "references/vscode-extension/",
+    "media/",
     "references/config-reference.md",
     "references/config-reference.zh-CN.md",
     "references/cursor-guard.example.json",

package/references/dashboard/public/app.js

@@ -674,9 +674,10 @@ function relativeTime(ts) {
 /* ── Data fetching ────────────────────────────────────────── */
 
 async function fetchJson(url) {
+  const base = window.__GUARD_BASE_URL__ || '';
   const sep = url.includes('?') ? '&' : '?';
   const tokenParam = window.__GUARD_TOKEN__ ? `${sep}token=${window.__GUARD_TOKEN__}` : '';
-  const r = await fetch(url + tokenParam);
+  const r = await fetch(base + url + tokenParam);
   if (!r.ok) throw new Error(`HTTP ${r.status}`);
   return r.json();
 }
@@ -1526,16 +1527,21 @@ function openDoctorDrawer() {
 /* ── Copy to clipboard ────────────────────────────────────── */
 
 async function copyText(text) {
-  try {
-    await navigator.clipboard.writeText(text);
-  } catch {
-    const ta = document.createElement('textarea');
-    ta.value = text;
-    ta.style.cssText = 'position:fixed;left:-9999px';
-    document.body.appendChild(ta);
-    ta.select();
-    document.execCommand('copy');
-    document.body.removeChild(ta);
+  if (window.__IN_VSCODE__ && window.acquireVsCodeApi) {
+    try { window.__vscodeApi = window.__vscodeApi || acquireVsCodeApi(); } catch { /* already acquired */ }
+    window.__vscodeApi?.postMessage({ type: 'copy', text });
+  } else {
+    try {
+      await navigator.clipboard.writeText(text);
+    } catch {
+      const ta = document.createElement('textarea');
+      ta.value = text;
+      ta.style.cssText = 'position:fixed;left:-9999px';
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand('copy');
+      document.body.removeChild(ta);
+    }
   }
   showToast(t('drawer.copied'));
 }
@@ -1704,9 +1710,10 @@ async function restartServer(banner) {
   banner.querySelector('.upgrade-banner-close').style.display = 'none';
 
   try {
+    const base = window.__GUARD_BASE_URL__ || '';
     const sep = '/api/restart'.includes('?') ? '&' : '?';
     const tokenParam = window.__GUARD_TOKEN__ ? `${sep}token=${window.__GUARD_TOKEN__}` : '';
-    await fetch('/api/restart' + tokenParam, { method: 'POST' });
+    await fetch(base + '/api/restart' + tokenParam, { method: 'POST' });
   } catch { /* server may close connection */ }
 
   btn.textContent = t('upgrade.waiting');
@@ -1714,7 +1721,7 @@ async function restartServer(banner) {
   for (let i = 0; i < 20; i++) {
     await new Promise(r => setTimeout(r, 500));
     try {
-      const r = await fetch('/api/version' + (window.__GUARD_TOKEN__ ? '?token=' + window.__GUARD_TOKEN__ : ''));
+      const r = await fetch((window.__GUARD_BASE_URL__ || '') + '/api/version' + (window.__GUARD_TOKEN__ ? '?token=' + window.__GUARD_TOKEN__ : ''));
       if (r.ok) { ready = true; break; }
     } catch { /* still restarting */ }
   }

package/references/vscode-extension/.vscodeignore

@@ -0,0 +1,4 @@
+.vscode/**
+node_modules/**
+*.md
+.gitignore

package/references/vscode-extension/extension.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const vscode = require('vscode');
+const { DashboardManager } = require('./lib/dashboard-manager');
+const { WebViewProvider } = require('./lib/webview-provider');
+const { StatusBarController } = require('./lib/status-bar');
+const { GuardTreeView } = require('./lib/tree-view');
+const { Poller } = require('./lib/poller');
+
+let dashMgr, poller, statusBar, treeView, webviewProvider;
+
+async function activate(context) {
+  dashMgr = new DashboardManager();
+  poller = new Poller(dashMgr);
+  statusBar = new StatusBarController(poller);
+  treeView = new GuardTreeView(poller, dashMgr);
+  webviewProvider = new WebViewProvider(context, dashMgr);
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('cursorGuard.openDashboard', () => {
+      if (!dashMgr.running) {
+        vscode.window.showWarningMessage('Cursor Guard: no projects detected. Add .cursor-guard.json to your workspace.');
+        return;
+      }
+      webviewProvider.show();
+    }),
+
+    vscode.commands.registerCommand('cursorGuard.snapshotNow', async () => {
+      const folders = vscode.workspace.workspaceFolders;
+      if (!folders || folders.length === 0) return;
+      const projectPath = folders[0].uri.fsPath;
+      const result = await dashMgr.snapshotNow(projectPath);
+      if (result?.status === 'created') {
+        vscode.window.showInformationMessage(`Cursor Guard: snapshot created (${result.changedCount || 0} changes)`);
+      } else if (result?.status === 'unchanged') {
+        vscode.window.showInformationMessage('Cursor Guard: no changes to snapshot');
+      } else {
+        vscode.window.showWarningMessage(`Cursor Guard: ${result?.error || 'snapshot failed'}`);
+      }
+      poller.forceRefresh();
+    }),
+
+    vscode.commands.registerCommand('cursorGuard.startWatcher', async () => {
+      const folders = vscode.workspace.workspaceFolders;
+      if (!folders || folders.length === 0) {
+        vscode.window.showWarningMessage('Cursor Guard: no workspace folder open.');
+        return;
+      }
+      const projectPath = folders[0].uri.fsPath;
+      const existingPid = dashMgr.getWatcherPid(projectPath);
+      if (existingPid) {
+        vscode.window.showInformationMessage(`Cursor Guard: watcher already running (PID ${existingPid})`);
+        return;
+      }
+      const pid = dashMgr.startWatcher(projectPath);
+      if (pid) {
+        vscode.window.showInformationMessage(`Cursor Guard: watcher started (PID ${pid})`);
+        setTimeout(() => poller.forceRefresh(), 2000);
+      } else {
+        vscode.window.showWarningMessage('Cursor Guard: failed to start watcher');
+      }
+    }),
+
+    vscode.commands.registerCommand('cursorGuard.stopWatcher', async () => {
+      const folders = vscode.workspace.workspaceFolders;
+      if (!folders || folders.length === 0) return;
+      const projectPath = folders[0].uri.fsPath;
+      const stopped = dashMgr.stopWatcher(projectPath);
+      if (stopped) {
+        vscode.window.showInformationMessage('Cursor Guard: watcher stopped');
+        setTimeout(() => poller.forceRefresh(), 1000);
+      } else {
+        vscode.window.showWarningMessage('Cursor Guard: no running watcher found');
+      }
+    }),
+
+    vscode.commands.registerCommand('cursorGuard.refreshTree', () => {
+      poller.forceRefresh();
+      treeView.refresh();
+    }),
+
+    statusBar,
+    poller,
+    treeView,
+    webviewProvider,
+  );
+
+  const started = await dashMgr.autoStart(vscode.workspace.workspaceFolders);
+  if (started) {
+    poller.start();
+    vscode.window.showInformationMessage(`Cursor Guard: dashboard started on port ${dashMgr.port}`);
+  }
+
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeWorkspaceFolders(async () => {
+      const restarted = await dashMgr.autoStart(vscode.workspace.workspaceFolders);
+      if (restarted && !poller._timer) poller.start();
+      poller.forceRefresh();
+    })
+  );
+}
+
+function deactivate() {
+  if (poller) poller.dispose();
+  if (statusBar) statusBar.dispose();
+  if (treeView) treeView.dispose();
+  if (webviewProvider) webviewProvider.dispose();
+  if (dashMgr) dashMgr.dispose();
+}
+
+module.exports = { activate, deactivate };

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

@@ -0,0 +1,127 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const { spawn } = require('child_process');
+
+const CONFIG_FILE = '.cursor-guard.json';
+
+class DashboardManager {
+  constructor() {
+    this._instance = null;
+    this._serverModule = null;
+  }
+
+  get running() { return !!this._instance; }
+  get port() { return this._instance?.port; }
+  get token() { return this._instance?.token; }
+  get baseUrl() { return this._instance ? `http://127.0.0.1:${this._instance.port}` : null; }
+  get registry() { return this._instance?.registry; }
+
+  async autoStart(workspaceFolders) {
+    if (!workspaceFolders || workspaceFolders.length === 0) return false;
+    const paths = workspaceFolders
+      .map(f => f.uri.fsPath)
+      .filter(p => fs.existsSync(path.join(p, CONFIG_FILE)));
+    if (paths.length === 0) return false;
+    return this.start(paths);
+  }
+
+  async start(paths) {
+    if (!this._serverModule) {
+      this._serverModule = require('../../dashboard/server');
+    }
+    const { startDashboardServer, getInstance } = this._serverModule;
+    const existing = getInstance();
+    if (existing) {
+      await startDashboardServer(paths, { silent: true });
+      this._instance = getInstance();
+    } else {
+      this._instance = await startDashboardServer(paths, { port: 3120, silent: true });
+    }
+    return true;
+  }
+
+  async fetchApi(endpoint) {
+    if (!this._instance) return null;
+    const url = `${this.baseUrl}${endpoint}${endpoint.includes('?') ? '&' : '?'}token=${this.token}`;
+    return new Promise((resolve, reject) => {
+      http.get(url, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); }
+          catch { resolve(null); }
+        });
+      }).on('error', () => resolve(null));
+    });
+  }
+
+  async getProjects() {
+    return this.fetchApi('/api/projects') || [];
+  }
+
+  async getPageData(projectId, scope) {
+    const scopeParam = scope ? `&scope=${scope}` : '';
+    return this.fetchApi(`/api/page-data?id=${projectId}${scopeParam}`);
+  }
+
+  async snapshotNow(projectPath) {
+    if (!projectPath) return;
+    try {
+      const { createGitSnapshot } = require('../../lib/core/snapshot');
+      const { loadConfig } = require('../../lib/utils');
+      const { cfg } = loadConfig(projectPath);
+      return createGitSnapshot(projectPath, cfg, { message: 'guard: manual snapshot via IDE extension' });
+    } catch (e) {
+      return { status: 'error', error: e.message };
+    }
+  }
+
+  startWatcher(projectPath) {
+    if (!projectPath) return null;
+    const backupScript = path.resolve(__dirname, '..', '..', 'lib', 'auto-backup.js');
+    const child = spawn(process.execPath, [backupScript, '--path', projectPath], {
+      cwd: projectPath,
+      stdio: 'ignore',
+      detached: true,
+    });
+    child.unref();
+    return child.pid;
+  }
+
+  stopWatcher(projectPath) {
+    if (!projectPath) return false;
+    try {
+      const lockPath = path.join(projectPath, '.cursor-guard-backup.lock');
+      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;
+      }
+    } catch { /* ok */ }
+    return false;
+  }
+
+  getWatcherPid(projectPath) {
+    try {
+      const lockPath = path.join(projectPath, '.cursor-guard-backup.lock');
+      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;
+      }
+    } catch { /* not running */ }
+    return null;
+  }
+
+  dispose() {
+    this._instance = null;
+  }
+}
+
+module.exports = { DashboardManager };

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

@@ -0,0 +1,61 @@
+'use strict';
+
+const vscode = require('vscode');
+
+const POLL_INTERVAL = 5000;
+
+class Poller {
+  constructor(dashMgr) {
+    this._dashMgr = dashMgr;
+    this._timer = null;
+    this._listeners = [];
+    this._data = new Map();
+  }
+
+  get data() { return this._data; }
+
+  onChange(fn) {
+    this._listeners.push(fn);
+    return { dispose: () => { this._listeners = this._listeners.filter(l => l !== fn); } };
+  }
+
+  _emit() {
+    for (const fn of this._listeners) {
+      try { fn(this._data); } catch { /* listener error */ }
+    }
+  }
+
+  start() {
+    if (this._timer) return;
+    this._poll();
+    this._timer = setInterval(() => this._poll(), POLL_INTERVAL);
+  }
+
+  stop() {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+  }
+
+  async _poll() {
+    if (!this._dashMgr.running) return;
+    try {
+      const projects = await this._dashMgr.getProjects();
+      if (!Array.isArray(projects)) return;
+      for (const p of projects) {
+        const pageData = await this._dashMgr.getPageData(p.id, 'dashboard');
+        this._data.set(p.id, { ...p, dashboard: pageData?.dashboard || null });
+      }
+      this._emit();
+    } catch { /* non-critical */ }
+  }
+
+  async forceRefresh() {
+    await this._poll();
+  }
+
+  dispose() {
+    this.stop();
+    this._listeners = [];
+  }
+}
+
+module.exports = { Poller };

package/references/vscode-extension/lib/status-bar.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const vscode = require('vscode');
+
+class StatusBarController {
+  constructor(poller) {
+    this._item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 100);
+    this._item.command = 'cursorGuard.openDashboard';
+    this._item.tooltip = 'Cursor Guard — click to open dashboard';
+    this._setIdle();
+    this._item.show();
+
+    this._sub = poller.onChange(data => this._update(data));
+  }
+
+  _setIdle() {
+    this._item.text = '$(shield) Guard: init...';
+    this._item.backgroundColor = undefined;
+    this._item.color = new vscode.ThemeColor('statusBar.foreground');
+  }
+
+  _update(data) {
+    let hasAlert = false;
+    let watcherRunning = false;
+    let alertFileCount = 0;
+    let projectCount = 0;
+
+    for (const [, p] of data) {
+      projectCount++;
+      const d = p.dashboard;
+      if (!d) continue;
+      if (d.alerts?.active) {
+        hasAlert = true;
+        alertFileCount = d.alerts.latest?.fileCount || 0;
+      }
+      if (d.watcher?.running) watcherRunning = true;
+    }
+
+    if (hasAlert) {
+      this._item.text = `$(bell~spin) Guard: ${alertFileCount} files!`;
+      this._item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+      this._item.color = undefined;
+      this._item.tooltip = `Cursor Guard — ALERT: ${alertFileCount} files changed rapidly. Click to open dashboard.`;
+    } else if (watcherRunning) {
+      this._item.text = '$(shield) Guard: OK';
+      this._item.backgroundColor = undefined;
+      this._item.color = new vscode.ThemeColor('statusBar.foreground');
+      this._item.tooltip = 'Cursor Guard — watcher running, no alerts. Click to open dashboard.';
+    } else if (projectCount > 0) {
+      this._item.text = '$(eye-closed) Guard: Unprotected';
+      this._item.backgroundColor = undefined;
+      this._item.color = new vscode.ThemeColor('statusBar.foreground');
+      this._item.tooltip = 'Cursor Guard — watcher NOT running. Click to open dashboard, or use Command Palette > Start Watcher.';
+    } else {
+      this._item.text = '$(shield) Guard';
+      this._item.backgroundColor = undefined;
+      this._item.color = new vscode.ThemeColor('statusBar.foreground');
+      this._item.tooltip = 'Cursor Guard — no projects detected';
+    }
+  }
+
+  dispose() {
+    this._sub?.dispose();
+    this._item.dispose();
+  }
+}
+
+module.exports = { StatusBarController };

package/references/vscode-extension/lib/tree-view.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const vscode = require('vscode');
+
+class GuardTreeView {
+  constructor(poller, dashMgr) {
+    this._poller = poller;
+    this._dashMgr = dashMgr;
+    this._onDidChange = new vscode.EventEmitter();
+    this.onDidChangeTreeData = this._onDidChange.event;
+
+    this._treeView = vscode.window.createTreeView('cursorGuardProjects', {
+      treeDataProvider: this,
+      showCollapseAll: true,
+    });
+
+    this._sub = poller.onChange(() => this._onDidChange.fire());
+  }
+
+  refresh() { this._onDidChange.fire(); }
+
+  getTreeItem(element) { return element; }
+
+  getChildren(element) {
+    if (!element) return this._getRootItems();
+    if (element.contextValue === 'project') return this._getProjectChildren(element.projectId);
+    if (element.contextValue === 'actions') return this._getActionItems();
+    return [];
+  }
+
+  _getRootItems() {
+    const data = this._poller.data;
+    const items = [];
+
+    if (data.size === 0) {
+      const hint = new TreeItem('No projects detected', 'info', {
+        icon: new vscode.ThemeIcon('info', new vscode.ThemeColor('charts.yellow')),
+        description: 'Add .cursor-guard.json',
+      });
+      items.push(hint);
+    } else {
+      for (const [id, p] of data) {
+        const d = p.dashboard;
+        const hasAlert = d?.alerts?.active;
+        const watcherOk = d?.watcher?.running;
+        const iconColor = hasAlert
+          ? new vscode.ThemeColor('charts.red')
+          : watcherOk
+            ? new vscode.ThemeColor('charts.green')
+            : new vscode.ThemeColor('charts.yellow');
+        const icon = hasAlert
+          ? new vscode.ThemeIcon('shield', iconColor)
+          : watcherOk
+            ? new vscode.ThemeIcon('shield', iconColor)
+            : new vscode.ThemeIcon('shield', iconColor);
+
+        const item = new TreeItem(p.name || id, 'project', {
+          icon,
+          description: hasAlert ? 'ALERT' : watcherOk ? 'Protected' : 'Unprotected',
+          collapsible: vscode.TreeItemCollapsibleState.Expanded,
+        });
+        item.projectId = id;
+        items.push(item);
+      }
+    }
+
+    const actionsItem = new TreeItem('Quick Actions', 'actions', {
+      icon: new vscode.ThemeIcon('zap', new vscode.ThemeColor('charts.blue')),
+      collapsible: vscode.TreeItemCollapsibleState.Collapsed,
+    });
+    items.push(actionsItem);
+
+    return items;
+  }
+
+  _getActionItems() {
+    const openDash = new TreeItem('Open Dashboard', 'action', {
+      icon: new vscode.ThemeIcon('dashboard', new vscode.ThemeColor('charts.blue')),
+    });
+    openDash.command = { command: 'cursorGuard.openDashboard', title: 'Open Dashboard' };
+
+    const snapshot = new TreeItem('Snapshot Now', 'action', {
+      icon: new vscode.ThemeIcon('device-camera', new vscode.ThemeColor('charts.purple')),
+    });
+    snapshot.command = { command: 'cursorGuard.snapshotNow', title: 'Snapshot Now' };
+
+    const startW = new TreeItem('Start Watcher', 'action', {
+      icon: new vscode.ThemeIcon('play', new vscode.ThemeColor('charts.green')),
+    });
+    startW.command = { command: 'cursorGuard.startWatcher', title: 'Start Watcher' };
+
+    const stopW = new TreeItem('Stop Watcher', 'action', {
+      icon: new vscode.ThemeIcon('debug-stop', new vscode.ThemeColor('charts.red')),
+    });
+    stopW.command = { command: 'cursorGuard.stopWatcher', title: 'Stop Watcher' };
+
+    const refresh = new TreeItem('Refresh', 'action', {
+      icon: new vscode.ThemeIcon('refresh', new vscode.ThemeColor('charts.orange')),
+    });
+    refresh.command = { command: 'cursorGuard.refreshTree', title: 'Refresh' };
+
+    return [openDash, snapshot, startW, stopW, refresh];
+  }
+
+  _getProjectChildren(projectId) {
+    const p = this._poller.data.get(projectId);
+    if (!p?.dashboard) {
+      return [new TreeItem('Loading...', 'loading', {
+        icon: new vscode.ThemeIcon('loading~spin', new vscode.ThemeColor('charts.blue')),
+      })];
+    }
+    const d = p.dashboard;
+    const items = [];
+
+    if (d.watcher?.running) {
+      const w = new TreeItem('Watcher: Running', 'watcher', {
+        icon: new vscode.ThemeIcon('eye', new vscode.ThemeColor('charts.green')),
+        description: d.watcher.pid ? `PID ${d.watcher.pid}` : '',
+      });
+      items.push(w);
+    } else {
+      const w = new TreeItem('Watcher: Stopped', 'watcher', {
+        icon: new vscode.ThemeIcon('eye-closed', new vscode.ThemeColor('charts.red')),
+        description: 'Click Quick Actions > Start',
+      });
+      items.push(w);
+    }
+
+    if (d.alerts?.active) {
+      const a = d.alerts.latest || {};
+      const alertItem = new TreeItem(
+        `ALERT: ${a.fileCount || '?'} files in ${a.windowSeconds || '?'}s`,
+        'alert',
+        {
+          icon: new vscode.ThemeIcon('bell', new vscode.ThemeColor('charts.red')),
+          description: `threshold: ${a.threshold}`,
+        }
+      );
+      items.push(alertItem);
+    } else {
+      items.push(new TreeItem('No alerts', 'noalert', {
+        icon: new vscode.ThemeIcon('check', new vscode.ThemeColor('charts.green')),
+      }));
+    }
+
+    if (d.lastBackup?.git) {
+      const ago = this._relativeTime(d.lastBackup.git.timestamp);
+      items.push(new TreeItem(`Last Backup: ${ago}`, 'backup', {
+        icon: new vscode.ThemeIcon('git-commit', new vscode.ThemeColor('charts.blue')),
+      }));
+    }
+
+    if (d.counts) {
+      const gitCount = d.counts.git?.commits || 0;
+      const shadowCount = d.counts.shadow?.snapshots || 0;
+      items.push(new TreeItem(`Git: ${gitCount}  Shadow: ${shadowCount}`, 'counts', {
+        icon: new vscode.ThemeIcon('database', new vscode.ThemeColor('charts.purple')),
+      }));
+    }
+
+    const health = d.health?.status || 'unknown';
+    const healthColor = health === 'healthy'
+      ? new vscode.ThemeColor('charts.green')
+      : health === 'critical'
+        ? new vscode.ThemeColor('charts.red')
+        : new vscode.ThemeColor('charts.yellow');
+    const healthIcon = health === 'healthy' ? 'pass-filled' : health === 'critical' ? 'error' : 'warning';
+    const healthItem = new TreeItem(`Health: ${health}`, 'health', {
+      icon: new vscode.ThemeIcon(healthIcon, healthColor),
+      description: d.health?.issues?.length > 0 ? d.health.issues[0] : '',
+    });
+    items.push(healthItem);
+
+    return items;
+  }
+
+  _relativeTime(ts) {
+    const diff = Date.now() - new Date(ts).getTime();
+    const sec = Math.floor(diff / 1000);
+    if (sec < 60) return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60) return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    return `${hr}h ago`;
+  }
+
+  dispose() {
+    this._sub?.dispose();
+    this._treeView.dispose();
+    this._onDidChange.dispose();
+  }
+}
+
+class TreeItem extends vscode.TreeItem {
+  constructor(label, contextValue, opts = {}) {
+    super(label, opts.collapsible || vscode.TreeItemCollapsibleState.None);
+    this.contextValue = contextValue;
+    if (opts.icon) this.iconPath = opts.icon;
+    if (opts.description) this.description = opts.description;
+  }
+}
+
+module.exports = { GuardTreeView };

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

@@ -0,0 +1,95 @@
+'use strict';
+
+const vscode = require('vscode');
+const fs = require('fs');
+const path = require('path');
+
+const PUBLIC_DIR = path.resolve(__dirname, '..', '..', 'dashboard', 'public');
+
+class WebViewProvider {
+  constructor(context, dashMgr) {
+    this._context = context;
+    this._dashMgr = dashMgr;
+    this._panel = null;
+  }
+
+  show() {
+    if (this._panel) {
+      this._panel.reveal();
+      return;
+    }
+
+    this._panel = vscode.window.createWebviewPanel(
+      'cursorGuardDashboard',
+      'Cursor Guard Dashboard',
+      vscode.ViewColumn.One,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+        localResourceRoots: [vscode.Uri.file(PUBLIC_DIR)],
+      }
+    );
+
+    this._panel.webview.html = this._buildHtml(this._panel.webview);
+    this._panel.iconPath = new vscode.ThemeIcon('shield');
+
+    this._panel.onDidDispose(() => { this._panel = null; });
+
+    this._panel.webview.onDidReceiveMessage(msg => {
+      if (msg.type === 'copy') {
+        vscode.env.clipboard.writeText(msg.text);
+        vscode.window.showInformationMessage('Copied to clipboard');
+      }
+    });
+  }
+
+  _buildHtml(webview) {
+    const htmlPath = path.join(PUBLIC_DIR, 'index.html');
+    let html = fs.readFileSync(htmlPath, 'utf-8');
+
+    const styleUri = webview.asWebviewUri(vscode.Uri.file(path.join(PUBLIC_DIR, 'style.css')));
+    const scriptUri = webview.asWebviewUri(vscode.Uri.file(path.join(PUBLIC_DIR, 'app.js')));
+
+    html = html.replace(/href="style\.css"/g, `href="${styleUri}"`);
+    html = html.replace(/src="app\.js"/g, `src="${scriptUri}"`);
+
+    const baseUrl = this._dashMgr.baseUrl || '';
+    const token = this._dashMgr.token || '';
+    const nonce = _getNonce();
+
+    const csp = [
+      `default-src 'none'`,
+      `style-src ${webview.cspSource} 'unsafe-inline'`,
+      `script-src 'nonce-${nonce}' ${webview.cspSource}`,
+      `font-src ${webview.cspSource}`,
+      `img-src ${webview.cspSource} data:`,
+      `connect-src ${baseUrl}`,
+    ].join('; ');
+
+    html = html.replace(
+      '</head>',
+      `<meta http-equiv="Content-Security-Policy" content="${csp}">
+<script nonce="${nonce}">
+  window.__GUARD_TOKEN__ = "${token}";
+  window.__GUARD_BASE_URL__ = "${baseUrl}";
+  window.__IN_VSCODE__ = true;
+</script>
+</head>`
+    );
+
+    return html;
+  }
+
+  dispose() {
+    if (this._panel) { this._panel.dispose(); this._panel = null; }
+  }
+}
+
+function _getNonce() {
+  let text = '';
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  for (let i = 0; i < 32; i++) text += chars.charAt(Math.floor(Math.random() * chars.length));
+  return text;
+}
+
+module.exports = { WebViewProvider };

package/references/vscode-extension/media/ICON_README.md

@@ -0,0 +1,5 @@
+## Extension Icon
+
+Place a 128x128 PNG file named `icon.png` in this directory for the VS Code marketplace listing.
+
+The `guard-icon.svg` is used for the activity bar sidebar icon.

package/references/vscode-extension/media/guard-icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/>
+  <path d="M9 12l2 2 4-4"/>
+</svg>

package/references/vscode-extension/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "cursor-guard-ide",
+  "displayName": "Cursor Guard",
+  "description": "AI code protection dashboard embedded in your IDE — real-time alerts, backup history, one-click snapshots",
+  "version": "4.7.0",
+  "publisher": "zhangqiang8vipp",
+  "license": "BUSL-1.1",
+  "engines": {
+    "vscode": "^1.74.0"
+  },
+  "categories": ["Other", "Visualization"],
+  "keywords": ["cursor", "ai-safety", "code-protection", "git-backup", "dashboard"],
+  "icon": "media/icon.png",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zhangqiang8vipp/cursor-guard"
+  },
+  "main": "./extension.js",
+  "activationEvents": [
+    "workspaceContains:.cursor-guard.json"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "cursorGuard.openDashboard",
+        "title": "Open Dashboard",
+        "category": "Cursor Guard",
+        "icon": "$(dashboard)"
+      },
+      {
+        "command": "cursorGuard.snapshotNow",
+        "title": "Snapshot Now",
+        "category": "Cursor Guard",
+        "icon": "$(device-camera)"
+      },
+      {
+        "command": "cursorGuard.startWatcher",
+        "title": "Start Watcher",
+        "category": "Cursor Guard",
+        "icon": "$(eye)"
+      },
+      {
+        "command": "cursorGuard.stopWatcher",
+        "title": "Stop Watcher",
+        "category": "Cursor Guard",
+        "icon": "$(eye-closed)"
+      },
+      {
+        "command": "cursorGuard.refreshTree",
+        "title": "Refresh",
+        "category": "Cursor Guard",
+        "icon": "$(refresh)"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "cursorGuard",
+          "title": "Cursor Guard",
+          "icon": "media/guard-icon.svg"
+        }
+      ]
+    },
+    "views": {
+      "cursorGuard": [
+        {
+          "id": "cursorGuardProjects",
+          "name": "Projects"
+        }
+      ]
+    },
+    "menus": {
+      "view/title": [
+        {
+          "command": "cursorGuard.openDashboard",
+          "when": "view == cursorGuardProjects",
+          "group": "navigation"
+        },
+        {
+          "command": "cursorGuard.refreshTree",
+          "when": "view == cursorGuardProjects",
+          "group": "navigation"
+        }
+      ]
+    }
+  }
+}