Watchdog — Extension Health & Rollback
Watchdog gives VS Code extension users and extension teams a local safety layer when editor updates go sideways.
Why it exists
When VS Code or a first-party integration updates, users blame the extension that stopped working. The publisher has almost no native tooling to answer:
- Is it our extension or the host update?
- Which extension versions drifted?
- What was the last known-good state?
- How do we get the user back to working quickly?
Watchdog solves the first local version of that problem.
How it works
Watchdog runs entirely on your machine. Four pieces work together:
Snapshots — a snapshot is the list of your installed extensions and their exact versions, plus the VS Code version at that moment. Watchdog reads this from the code CLI (code --list-extensions --show-versions), falling back to the in-editor extensions API if the CLI isn't available. Snapshots are stored as JSON in the extension's global storage (the last 30 are kept).
Health checks — for each extension ID in watchdog.monitoredExtensions, Watchdog calls extension.activate() and times it. The result per extension is healthy, missing (not installed), or failed (threw on activation). The overall check is healthy only if every monitored extension activates; it's failing if any are missing/failed, and warning for non-blocking issues (e.g. the CLI is unavailable). Every healthy check automatically saves a new known-good snapshot.
Diff — each health check compares your current extensions against the last known-good snapshot and reports what was added, removed, or version-changed. That's how you see exactly what drifted after a VS Code update.
Restore — when something breaks, Watchdog builds a restore plan (which versions to reinstall, optionally which to uninstall) and runs code --install-extension id@version --force for each. It always takes a safety snapshot first and never touches itself.
It's also automatic: on startup and whenever the VS Code version changes, Watchdog snapshots and (optionally) runs a health check — so breakage is caught the moment an update lands, not when you file a support ticket.
Free
- Save versioned snapshots of installed user extensions
- Run activation-based health checks for monitored extensions
- Compare current state to the last known-good snapshot
- Restore pinned extension versions through the
code CLI
- Auto-snapshot and auto-check after VS Code version changes
Pro
- Canary checks against Insider / preview builds — run a health check that flags failures specific to the preview channel
- Incident clustering — your stored health checks grouped by VS Code version, surfacing which versions correlate with failures and which extensions break
- Shared known-good team policies — export the agreed extension set to a committed
.watchdog/policy.json and restore any machine to it
- Alert webhook — when an automatic health check fails, Watchdog posts a Slack-compatible alert to a webhook you configure
Activate with a license key from marketplace.dashovia.com/extensions/watchdog.
Good first use cases
- Track Copilot, Chat, Python, Remote SSH, or your own internal extension
- Catch breakage right after a VS Code update
- Revert to a known-good extension set without manually hunting versions
- Generate a simple local health report before opening a support ticket
Commands
Open the Command Palette (Ctrl/Cmd+Shift+P) and type "Watchdog".
Free
| Command |
What it does |
Watchdog: Create Snapshot |
Save a snapshot of your current installed extensions + versions. |
Watchdog: Run Health Check |
Activate every monitored extension, time it, and open a report. Saves a known-good snapshot if all pass. |
Watchdog: Restore Snapshot |
Pick a past snapshot and reinstall those extension versions via the code CLI. |
Watchdog: Show Last Report |
Reopen the most recent health report. |
Pro
| Command |
What it does |
Watchdog: Run Canary Check |
Run a health check labelled for the current channel; flags failures specific to an Insider / preview build. |
Watchdog: Incident Clustering |
Open a panel grouping past failing checks by VS Code version, showing failure rate and the offending extensions. |
Watchdog: Export Team Policy |
Write your known-good extension set to .watchdog/policy.json (commit it to share a team baseline). |
Watchdog: Restore from Team Policy |
Reconcile this machine to the committed team policy. |
The status-bar item ($(shield) Watchdog) shows the latest health state — click it to run a check or open the last report.
Settings
watchdog.licenseKey: (Pro) your Watchdog Pro license keywatchdog.alertWebhook: (Pro) Slack-compatible webhook URL alerted when an automatic health check failswatchdog.teamPolicyPath: (Pro) path for the shared policy file (default .watchdog/policy.json)watchdog.monitoredExtensions: extension IDs to smoke test, like GitHub.copilotwatchdog.autoSnapshotOnStartup: snapshot on first run and after VS Code version changeswatchdog.autoCheckOnVersionChange: run a health check automatically after a VS Code updatewatchdog.autoRestoreOnHealthCheckFailure: restore the last known-good snapshot after an automatic failed checkwatchdog.promptBeforeRestore: require confirmation before reinstalling versionswatchdog.uninstallMissingExtensionsOnRestore: optionally remove extensions not present in the chosen snapshotwatchdog.codeCliPath: CLI path used for installs and rollbacks
Current limits
- Health checks are activation-based, not deep workflow tests.
- Restore targets extension versions, not the full VS Code application binary.
- Incident clustering and team policies run on your local report store / a committed file; cross-machine aggregation into a hosted dashboard is a future layer.
- Restore depends on the VS Code CLI being available.
