tabctl 0.5.2 → 0.6.0-alpha.1

package/README.md

@@ -1,28 +1,89 @@
 # tabctl
 
-`tabctl` is a command-line tool that gives you terminal control over your browser tabs. List, search, group, move, close, deduplicate, inspect, and report on tabs without leaving your terminal — across Chrome and Edge.
+Every open tab is a thread you forgot to pull. Tabctl finds them all.
 
-It works through a lightweight local stack: the CLI talks to a native messaging host, which proxies requests to a browser extension. A policy file can protect pinned tabs or specific groups from automated actions, and every mutation is undoable.
+A command-line instrument for browser tab orchestration — list, search, group, archive, close, undo — wired into Edge or Chrome through a native messaging bridge. Built for humans who hoard tabs and the AI agents who clean up after them.
 
-This repo contains:
-- Chrome/Edge extension (tab/group inspection + actions)
-- Native messaging host (Node)
-- CLI (`tabctl`) for on-demand workflows
+## Install
+
+```bash
+mise use -g github:ekroon/tabctl   # install the tabctl binary
+tabctl setup --browser edge         # or: --browser chrome
+# Load the extension: edge://extensions → Developer mode → Load unpacked → paste: ~/.local/state/tabctl/extension/
+tabctl ping
+```
+
+If it pings back, the wire is live. You're connected.
+
+### Alternative: build from source
+
+```bash
+cargo install --path rust/crates/tabctl
+```
+
+> **Legacy:** `npm install -g tabctl` still works for the Node.js-based distribution but is no longer the primary install method. No Node.js or Go is required at runtime — the single `tabctl` binary handles everything.
+
+## Agent Skill
+
+Give your coding agent eyes into the browser. One command and it learns the protocol.
+
+```bash
+tabctl skill
+# or: npx skills add https://github.com/ekroon/tabctl --skill tabctl -a opencode -a github-copilot -a claude-code
+```
+
+## Safety
+
+Nothing leaves your machine. No cloud. No telemetry. Just a socket between your terminal and your browser, quiet as rain on neon.
+
+Every mutation is undoable — `tabctl undo` rewinds closes, archives, and group changes like they never happened. A configurable policy layer shields pinned tabs and protected domains from accidental destruction. You pull the trigger; tabctl keeps the safety on until you mean it.
+
+## What You Can Say
+
+When tabctl is installed as a skill, your agent sees what you see. Just talk to it.
+
+> *"Which of my tabs can I close?"*
+> The agent scans for duplicates, stale pages, and tabs you haven't touched in days — then offers to clean house.
+
+> *"Are any of my open tabs relevant to my note on Project Helios?"*
+> When connected to Obsidian, your agent cross-references every open tab against your notes and surfaces the ones that matter.
+
+> *"I just finished researching service mesh architectures. Organize what I found."*
+> Groups your tabs by theme, extracts key URLs, and drops a summary into your notes — before you forget what you were looking at.
+
+> *"Where's that AWS pricing page I had open somewhere?"*
+> The agent searches your open tabs and groups by title and URL — and brings it back into focus.
+
+> *"Pull every error message from my open Sentry tabs into a markdown table."*
+> The agent reads each tab, extracts what you need, and formats it — no copy-paste, no context switching.
+
+> *"Group everything by project. You know which ones."*
+> Your agent infers context from URLs, titles, and your workspace — then sorts ninety tabs into five groups with names that actually make sense.
+
+---
 
-The host only runs while the browser is open and the extension is connected.
+`tabctl` is a single Rust binary that serves as both the CLI and the native messaging host. The CLI sends commands over a Unix socket (or named pipe on Windows) to the host, which proxies them to the browser extension via native messaging. The `tabctl host` subcommand is the native messaging entry point — invoked automatically by the browser, not manually.
+
+This repo contains:
+- Chrome/Edge extension (`src/extension/`, the only TypeScript component)
+- Rust workspace (`rust/crates/*`) — single `tabctl` binary for CLI + host + shared runtime
+- Node packaging/build scripts for distribution (legacy)
 
 ## Quick Start
 
 ### 1. Build and install
 
+```bash
+cargo install --path rust/crates/tabctl   # puts tabctl on your PATH
+```
+
+For development with the full build pipeline (extension + Rust):
+
 ```bash
 npm install
 npm run build
-npm link          # puts tabctl on your PATH
 ```
 
-If you haven't run `npm link`, you can always use `node ./cli/tabctl.js` instead of `tabctl`.
-
 ### 2. Set up your browser
 
 Run setup — it syncs the extension, tells you where to load it, and auto-derives the extension ID:
@@ -37,8 +98,16 @@ This will:
 2. Print the path (and copy it to your clipboard)
 3. Ask you to load it as an unpacked extension in `chrome://extensions`
 4. Auto-derive the extension ID from the installed path
+5. Download the version-pinned release extension asset (`tabctl-extension.zip` + `.sha256`) into the tabctl data directory for offline/manual recovery
+
+Optional setup release overrides:
+- Flags: `--release-repo`, `--release-tag` (or `--release-version`), `--release-asset`, `--skip-extension-download`
+- Env vars: `TABCTL_RELEASE_REPO`, `TABCTL_RELEASE_TAG`, `TABCTL_RELEASE_ASSET`, `TABCTL_SETUP_FETCH_EXTENSION=0`
+- Precedence: flags override env vars, then built-in defaults; if download fails, setup continues and includes warning details in setup output.
 
 > **Edge?** Use `--browser edge` and load from `edge://extensions` instead.
+>
+> **Windows:** setup verifies connectivity after writing setup artifacts and checks the runtime extension ID reported by the browser. Connectivity failures and runtime extension ID mismatches exit non-zero and print manual recovery steps (including expected vs runtime IDs).
 
 If you need to override the auto-derived ID (e.g. for a custom extension path):
 
@@ -159,6 +228,28 @@ See [CLI.md](CLI.md#configuration) for full details.
 - Socket: `<dataDir>/tabctl.sock` (default: `~/.local/state/tabctl/tabctl.sock`)
 - Undo log: `<dataDir>/undo.jsonl` (default: `~/.local/state/tabctl/undo.jsonl`)
 - Profile registry: `<configDir>/profiles.json`
+- WSL TCP port file: `<dataDir>/tcp-port` (written by the Windows host)
+
+## Windows + WSL transport
+
+On Windows, the host exposes a dual endpoint model:
+- Windows native clients use a named pipe endpoint (`\\.\pipe\tabctl-<hash>`).
+- WSL/Linux clients use `tcp://127.0.0.1:<port>`, with the host writing `<dataDir>/tcp-port`.
+
+WSL endpoint discovery (CLI):
+1. `TABCTL_SOCKET` (explicit endpoint); if this is a pipe endpoint in WSL, CLI still prefers discovered TCP.
+2. `TABCTL_TCP_PORT` (forces `127.0.0.1:<port>`).
+3. `tcp-port` file discovery from resolved data dir (and equivalent `/mnt/c/Users/*/.../tabctl/.../tcp-port` locations).
+4. Fallback: `tcp://127.0.0.1:38000`.
+
+Relevant knobs: `TABCTL_SOCKET`, `TABCTL_TCP_PORT`, `TABCTL_PROFILE`, `TABCTL_DATA_DIR`, `TABCTL_STATE_DIR`, `TABCTL_CONFIG_DIR`.
+
+## Troubleshooting (setup/ping on Windows + WSL)
+
+- `tabctl setup` fails with `Windows setup verification failed`: check `data.verification.reason` in JSON output (`ping-timeout`, `socket-not-found`, `socket-refused`, `ping-not-ok`, `extension-id-mismatch`), then follow printed manual steps.
+- Runtime ID mismatch (`extension-id-mismatch`): compare expected vs runtime IDs from setup output, then rerun setup with the runtime ID shown by `edge://extensions` / `chrome://extensions`:
+  - `tabctl setup --browser <edge|chrome> --extension-id <runtime-id>`
+- `tabctl ping` returns connect errors (`ENOENT`, `ECONNREFUSED`, timeout): ensure extension is loaded and active, rerun `tabctl setup`, and in WSL verify `TABCTL_TCP_PORT` or `<dataDir>/tcp-port` matches a listening localhost port.
 
 ## Multi-Browser Setup
 
@@ -211,21 +302,29 @@ Policy is shared across all profiles.
 
 ## Development
 
-### TypeScript workflow
-Source lives in `src/` and compiles to `build/`, then syncs to the runtime locations:
-- `src/extension/background.ts` -> `extension/background.js`
-- `src/host/host.ts` -> `host/host.js`
-- `src/cli/tabctl.ts` -> `cli/tabctl.js`
-- `src/tests/unit/*.ts` -> `tests/unit/*.js`
+### Build workflow
+The single `tabctl` binary is built from the Rust workspace (`rust/`). TypeScript is limited to the browser extension boundary (`src/extension/`). No Node.js or Go is required at runtime.
 
-Build and test:
+Build and verify:
 
 ```bash
-npm install
-npm run build
-npm test
+cargo build --release -p tabctl   # build the binary
+npm install && npm run build      # full pipeline (extension + Rust)
+npm test                          # unit tests
+```
+
+Rust-only validation:
+```bash
+npm run rust:verify
+```
+
+Integration script (currently Rust-suite parity in CI/local):
+```bash
+npm run test:integration
 ```
 
+WSL CI validates the WSL->Windows invocation bridge (`test.yml` `wsl` job) with phases: `prerequisites`, `diagnostics`, `build_and_unit`, `setup_validation`, `windows_invocation`, `integration`. Runtime/build execution is delegated to Windows commands (`cmd.exe`/`powershell.exe`), so WSL-local Rust compilation is not required.
+
 ### Versioning
 The base version lives in `package.json` and is embedded into the CLI, host, and extension at build time.
 
@@ -234,6 +333,25 @@ Commands:
 npm run bump:patch
 npm run bump:minor
 npm run bump:major
+npm run bump:alpha
+npm run bump:rc
+npm run bump:stable
+```
+
+Pre-release staging flow:
+- `bump:alpha` creates/increments `x.y.z-alpha.N`
+- `bump:rc` promotes alpha to `x.y.z-rc.1` (or increments RC)
+- `bump:stable` drops the prerelease suffix for final stable publish
+
+Release publishing (`.github/workflows/publish.yml`) enforces:
+- Git tag must match `package.json` version (`v<version>`)
+- prerelease tags publish to `alpha`/`rc`; stable publishes to `latest`
+- `npm run build` and `npm test` must pass before publish
+- release assets include `tabctl-extension.zip` plus `tabctl-extension.zip.sha256`
+
+Fetch the extension asset from a release with:
+```bash
+tabctl extension-fetch --version 0.5.3
 ```
 
 Local builds default to a dev version when a `.git` directory is present, appending the short SHA.

package/dist/extension/background.js

@@ -3408,6 +3408,7 @@
       case "ping":
         return {
           now: Date.now(),
+          runtimeId: chrome.runtime.id,
           version: VERSION_INFO.version,
           baseVersion: VERSION_INFO.baseVersion,
           gitSha: VERSION_INFO.gitSha,
@@ -3416,6 +3417,7 @@
         };
       case "version":
         return {
+          runtimeId: chrome.runtime.id,
           version: VERSION_INFO.version,
           baseVersion: VERSION_INFO.baseVersion,
           gitSha: VERSION_INFO.gitSha,

package/dist/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Tab Control",
-  "version": "0.5.2",
+  "version": "0.6.0-alpha.1",
   "description": "Archive and manage browser tabs with CLI support",
   "permissions": [
     "tabs",
@@ -19,5 +19,5 @@
   "background": {
     "service_worker": "background.js"
   },
-  "version_name": "0.5.2"
+  "version_name": "0.6.0-alpha.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.5.2",
+  "version": "0.6.0-alpha.1",
   "description": "CLI tool to manage and analyze browser tabs",
   "license": "MIT",
   "repository": {
@@ -27,13 +27,21 @@
     "dist/extension"
   ],
   "scripts": {
-    "build": "node scripts/gen-version.js && tsc -p tsconfig.json && node scripts/copy-artifacts.js && node scripts/build-launcher.js && node scripts/bundle-extension.js",
+    "build": "node scripts/gen-version.js && tsc -p tsconfig.json && node scripts/copy-artifacts.js && node scripts/bundle-extension.js && cargo build --manifest-path rust/Cargo.toml --workspace",
+    "build:launcher": "node scripts/build-launcher.js",
     "bump:major": "node scripts/bump-version.js major",
     "bump:minor": "node scripts/bump-version.js minor",
     "bump:patch": "node scripts/bump-version.js patch",
-    "test": "npm run build && node --test --test-timeout=5000 dist/tests/unit/*.js && node dist/scripts/integration-test.js",
-    "test:unit": "npm run build && node --test --test-timeout=5000 dist/tests/unit/*.js",
-    "test:integration": "node dist/scripts/integration-test.js",
+    "bump:alpha": "node scripts/bump-version.js alpha",
+    "check:targets": "bash scripts/check-targets.sh",
+    "bump:rc": "node scripts/bump-version.js rc",
+    "bump:stable": "node scripts/bump-version.js stable",
+    "rust:check": "cargo check --manifest-path rust/Cargo.toml --workspace --all-targets",
+    "rust:test": "cargo test --manifest-path rust/Cargo.toml --workspace --all-targets",
+    "rust:verify": "cargo fmt --manifest-path rust/Cargo.toml --all -- --check && cargo clippy --manifest-path rust/Cargo.toml --workspace --all-targets -- -D warnings && npm run rust:test",
+    "test": "npm run build && npm run rust:verify",
+    "test:unit": "npm run rust:test",
+    "test:integration": "npm run rust:test",
     "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" ",
     "prepare": "git rev-parse --git-dir >/dev/null 2>&1 && git config core.hooksPath .githooks || true"
   },

package/dist/cli/lib/args.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeGroupColor = normalizeGroupColor;
-exports.normalizeSignals = normalizeSignals;
-exports.validateSignals = validateSignals;
-exports.parseArgs = parseArgs;
-const constants_1 = require("./constants");
-const options_1 = require("./options");
-const output_1 = require("./output");
-function normalizeGroupColor(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim().toLowerCase();
-    if (!trimmed) {
-        return undefined;
-    }
-    if (!constants_1.GROUP_COLORS.has(trimmed)) {
-        (0, output_1.errorOut)(`Invalid color: ${value}. Use one of: ${Array.from(constants_1.GROUP_COLORS).join(", ")}`);
-    }
-    return trimmed;
-}
-function normalizeSignals(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((signal) => String(signal).trim()).filter(Boolean);
-}
-function validateSignals(signals) {
-    for (const signal of signals) {
-        if (!constants_1.SUPPORTED_SIGNAL_SET.has(signal)) {
-            (0, output_1.errorOut)(`Unknown signal: ${signal}. Use one of: ${constants_1.SUPPORTED_SIGNALS.join(", ")}`);
-        }
-    }
-}
-function normalizeCommand(value) {
-    if (!value) {
-        return value;
-    }
-    if (value === "groups" || value === "group") {
-        return "group-list";
-    }
-    const meta = options_1.COMMANDS[value];
-    if (!meta?.aliases || meta.aliases.length === 0) {
-        return value;
-    }
-    return meta.aliases[0] ?? value;
-}
-function parseArgs(argv) {
-    const args = [...argv];
-    let command;
-    const options = { _: [] };
-    const warnings = [];
-    const pendingFlags = [];
-    const allowedFlags = (0, options_1.getAllowedFlags)();
-    const booleanFlags = (0, options_1.getBooleanFlags)();
-    while (args.length > 0) {
-        const arg = args.shift();
-        if (!arg.startsWith("--")) {
-            if (!command) {
-                command = normalizeCommand(arg);
-                if (command) {
-                    const commandAllowedFlags = (0, options_1.getCommandAllowedFlags)(command);
-                    for (const pending of pendingFlags) {
-                        if (!commandAllowedFlags.has(pending)) {
-                            warnings.push(`--${pending} is not supported by ${command}`);
-                        }
-                    }
-                }
-                continue;
-            }
-            options._.push(arg);
-            continue;
-        }
-        const key = arg.slice(2);
-        if (!allowedFlags.has(key)) {
-            if (key === "format") {
-                (0, output_1.errorOut)("Unknown option: --format");
-            }
-            (0, output_1.errorOut)(`Unknown option: --${key}`);
-        }
-        if (command) {
-            const commandAllowedFlags = (0, options_1.getCommandAllowedFlags)(command);
-            if (!commandAllowedFlags.has(key)) {
-                warnings.push(`--${key} is not supported by ${command}`);
-            }
-        }
-        else {
-            pendingFlags.push(key);
-        }
-        // Boolean flags (no value needed)
-        if (booleanFlags.has(key)) {
-            options[key] = true;
-            continue;
-        }
-        // Value required
-        const value = args.shift();
-        if (value == null) {
-            (0, output_1.errorOut)(`Missing value for --${key}`);
-        }
-        // Repeatable flags (accumulate into arrays)
-        if (key === "signal") {
-            if (!options.signal) {
-                options.signal = [];
-            }
-            options.signal.push(value);
-            continue;
-        }
-        if (key === "tab") {
-            if (!options.tab) {
-                options.tab = [];
-            }
-            options.tab.push(value);
-            continue;
-        }
-        if (key === "agent") {
-            if (!options.agent) {
-                options.agent = [];
-            }
-            options.agent.push(value);
-            continue;
-        }
-        if (key === "url") {
-            if (!options.url) {
-                options.url = [];
-            }
-            options.url.push(value);
-            continue;
-        }
-        if (key === "selector") {
-            if (!options.selector) {
-                options.selector = [];
-            }
-            options.selector.push(value);
-            continue;
-        }
-        // Single value flags
-        options[key] = value;
-    }
-    return { command, options, warnings };
-}

package/dist/cli/lib/client.js

@@ -1,83 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRequestId = createRequestId;
-exports.sendRequest = sendRequest;
-exports.fetchSnapshot = fetchSnapshot;
-exports.sendFireAndForget = sendFireAndForget;
-const node_net_1 = __importDefault(require("node:net"));
-const constants_1 = require("./constants");
-function createRequestId() {
-    return `req-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-}
-function sendRequest(payload, onProgress) {
-    return new Promise((resolve, reject) => {
-        const { socketPath } = (0, constants_1.resolveConfig)();
-        const client = node_net_1.default.createConnection(socketPath);
-        let buffer = "";
-        client.on("connect", () => {
-            client.write(`${JSON.stringify(payload)}\n`);
-        });
-        client.on("data", (data) => {
-            buffer += data;
-            let index;
-            while ((index = buffer.indexOf("\n")) >= 0) {
-                const line = buffer.slice(0, index).trim();
-                buffer = buffer.slice(index + 1);
-                if (!line) {
-                    continue;
-                }
-                let response;
-                try {
-                    response = JSON.parse(line);
-                }
-                catch (error) {
-                    client.end();
-                    client.destroy();
-                    reject(error);
-                    return;
-                }
-                if (response.progress && onProgress) {
-                    onProgress(response);
-                    continue;
-                }
-                client.end();
-                client.destroy();
-                resolve(response);
-                return;
-            }
-        });
-        client.on("error", (error) => {
-            reject(error);
-        });
-    });
-}
-async function fetchSnapshot() {
-    const response = await sendRequest({ id: createRequestId(), action: "list", params: {} });
-    if (!response.ok) {
-        return null;
-    }
-    return response.data;
-}
-/** Send a request without waiting for a response (fire-and-forget). */
-function sendFireAndForget(payload) {
-    try {
-        const { socketPath } = (0, constants_1.resolveConfig)();
-        const client = node_net_1.default.createConnection(socketPath);
-        client.on("connect", () => {
-            client.write(`${JSON.stringify(payload)}\n`);
-            // Unref after write so Node can exit without waiting for response
-            client.unref();
-            const timer = setTimeout(() => { client.end(); client.destroy(); }, 200);
-            timer.unref();
-        });
-        client.on("error", () => {
-            // Silently ignore — this is best-effort
-        });
-    }
-    catch {
-        // Silently ignore
-    }
-}

package/dist/cli/lib/commands/doctor.js

@@ -1,134 +0,0 @@
-"use strict";
-/**
- * Doctor command handler: diagnose and repair profile health.
- *
- * Checks each profile's wrapper for valid Node/host paths, verifies
- * extension sync status, and optionally auto-repairs broken wrappers.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDoctor = runDoctor;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("../../../shared/config");
-const profiles_1 = require("../../../shared/profiles");
-const wrapper_health_1 = require("../../../shared/wrapper-health");
-const extension_sync_1 = require("../../../shared/extension-sync");
-const setup_1 = require("./setup");
-const output_1 = require("../output");
-function checkProfile(name, entry, fix) {
-    const wrapperPath = (0, wrapper_health_1.resolveWrapperPath)(entry.dataDir);
-    const check = (0, wrapper_health_1.checkWrapper)(wrapperPath);
-    const issues = [...check.issues];
-    let fixed = false;
-    if (fix && !check.ok && check.info) {
-        const needsNodeFix = !node_fs_1.default.existsSync(check.info.nodePath);
-        const needsHostFix = !node_fs_1.default.existsSync(check.info.hostPath);
-        if (needsNodeFix || needsHostFix) {
-            const newNodePath = needsNodeFix ? process.execPath : check.info.nodePath;
-            let newHostPath = check.info.hostPath;
-            if (needsHostFix) {
-                // Use the stable bundled host path
-                try {
-                    const config = (0, config_1.resolveConfig)();
-                    newHostPath = (0, extension_sync_1.resolveInstalledHostPath)(config.baseDataDir);
-                    if (!node_fs_1.default.existsSync(newHostPath)) {
-                        issues.push(`Bundled host not found at ${newHostPath} — run: tabctl setup --browser ${entry.browser}`);
-                    }
-                }
-                catch {
-                    issues.push("Could not resolve bundled host path");
-                }
-            }
-            try {
-                (0, setup_1.writeWrapper)(newNodePath, newHostPath, check.info.profileName, node_path_1.default.dirname(wrapperPath));
-                fixed = true;
-                // Update issue messages to show they were fixed
-                const fixedIssues = [];
-                if (needsNodeFix) {
-                    fixedIssues.push(`Fixed Node path: ${check.info.nodePath} → ${newNodePath}`);
-                }
-                if (needsHostFix) {
-                    fixedIssues.push(`Fixed host path: ${check.info.hostPath} → ${newHostPath}`);
-                }
-                // Replace original issues with fixed messages
-                issues.length = 0;
-                issues.push(...fixedIssues);
-            }
-            catch (err) {
-                issues.push(`Failed to fix wrapper: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-    return {
-        ok: check.ok || fixed,
-        browser: entry.browser,
-        dataDir: entry.dataDir,
-        wrapperPath,
-        issues,
-        fixed,
-    };
-}
-function runDoctor(options, prettyOutput) {
-    const fix = options.fix === true;
-    const config = (0, config_1.resolveConfig)();
-    const registry = (0, profiles_1.loadProfiles)(config.configDir);
-    const profileNames = Object.keys(registry.profiles);
-    if (profileNames.length === 0) {
-        (0, output_1.errorOut)("No profiles configured. Run: tabctl setup --browser <edge|chrome>");
-    }
-    // Check each profile
-    const profiles = {};
-    for (const name of profileNames) {
-        profiles[name] = checkProfile(name, registry.profiles[name], fix);
-    }
-    // Check extension sync status
-    let extensionCheck;
-    try {
-        const sync = (0, extension_sync_1.checkExtensionSync)(config.baseDataDir);
-        extensionCheck = {
-            ok: !sync.needsSync,
-            synced: !sync.needsSync,
-            bundledVersion: sync.bundledVersion,
-            installedVersion: sync.installedVersion,
-        };
-    }
-    catch {
-        extensionCheck = {
-            ok: false,
-            synced: false,
-            bundledVersion: null,
-            installedVersion: null,
-        };
-    }
-    // Summary
-    const total = profileNames.length;
-    const healthy = Object.values(profiles).filter(p => p.ok).length;
-    const broken = total - healthy;
-    const fixed = Object.values(profiles).filter(p => p.fixed).length;
-    const allOk = broken === 0 && extensionCheck.ok;
-    (0, output_1.printJson)({
-        ok: allOk,
-        action: "doctor",
-        data: {
-            profiles,
-            extension: extensionCheck,
-            summary: { total, healthy, broken, fixed },
-        },
-    }, prettyOutput);
-    // Helpful stderr hints
-    if (!allOk && !fix) {
-        const brokenNames = Object.entries(profiles)
-            .filter(([, p]) => !p.ok)
-            .map(([n]) => n);
-        if (brokenNames.length > 0) {
-            process.stderr.write(`\nBroken profiles: ${brokenNames.join(", ")}\n`);
-            process.stderr.write("Run: tabctl doctor --fix\n\n");
-        }
-    }
-    if (fixed > 0) {
-        process.stderr.write(`\nFixed ${fixed} profile(s). Verify: tabctl ping\n\n`);
-    }
-}