tabctl 0.5.3 → 0.6.0-alpha.2

package/README.md

@@ -7,13 +7,21 @@ A command-line instrument for browser tab orchestration — list, search, group,
 ## Install
 
 ```bash
-npm install -g tabctl
-tabctl setup --browser chrome
-# Load the extension: chrome://extensions → Developer mode → Load unpacked → paste: ~/.local/state/tabctl/extension/
+mise use -g github:ekroon/tabctl   # install the tabctl binary
+tabctl setup --browser edge --extension-id <id>   # or: --browser chrome --extension-id <id>
+# 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.
+Setup writes the wrapper script, native messaging manifest, and registers the profile in one step. Works on macOS, Linux, and Windows. 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
 
@@ -54,48 +62,54 @@ When tabctl is installed as a skill, your agent sees what you see. Just talk to
 
 ---
 
-`tabctl` works through a lightweight local stack: the CLI talks to a native messaging host, which proxies requests to a browser extension. 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 (tab/group inspection + actions)
-- Native messaging host (Node)
-- CLI (`tabctl`) for on-demand workflows
+- 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:
+Run setup with your browser's extension ID — it writes the manifest, wrapper script, and registers the profile:
 
 <!-- test: "setup explicit --extension-id overrides auto-derived ID" -->
 ```bash
-tabctl setup --browser chrome
+tabctl setup --browser chrome --extension-id <your-extension-id>
 ```
 
 This will:
-1. Copy the extension to a stable location (`~/.local/state/tabctl/extension/`)
-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
+1. Write the native messaging manifest and wrapper script
+2. Register the browser profile in `profiles.json`
+3. Download the version-pinned release extension asset (`tabctl-extension.zip` + `.sha256`) into the tabctl data directory
+4. Copy the extension to a stable location (`~/.local/state/tabctl/extension/`)
+5. Print the path for loading as an unpacked extension in `chrome://extensions`
+
+Without `--extension-id`, setup only downloads the extension and outputs JSON (no manifest or wrapper writes).
 
 > **Edge?** Use `--browser edge` and load from `edge://extensions` instead.
+>
+> **Cross-platform:** setup works on macOS, Linux, and Windows. On 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):
-
-<!-- test: "setup writes native host manifest for chrome" -->
-```bash
-tabctl setup --browser chrome --extension-id <your-extension-id>
-```
+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.
 
 ### 3. Verify and explore
 
@@ -209,6 +223,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
 
@@ -219,10 +255,10 @@ tabctl supports multiple browser profiles. Each profile connects to a different
 <!-- test: "setup writes native host manifest", "setup writes native host manifest for chrome", "setup --name creates custom-named profile", "profile-list with multiple profiles shows all", "profile-switch success updates default", "--profile flag overrides active profile" -->
 ```bash
 # Setup for Edge
-tabctl setup --browser edge
+tabctl setup --browser edge --extension-id <edge-extension-id>
 
 # Setup for Chrome (with custom name)
-tabctl setup --browser chrome --name chrome-work
+tabctl setup --browser chrome --name chrome-work --extension-id <chrome-extension-id>
 
 # List profiles
 tabctl profile-list
@@ -261,21 +297,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.
 
@@ -284,6 +328,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.3",
+  "version": "0.6.0-alpha.2",
   "description": "Archive and manage browser tabs with CLI support",
   "permissions": [
     "tabs",
@@ -19,5 +19,5 @@
   "background": {
     "service_worker": "background.js"
   },
-  "version_name": "0.5.3"
+  "version_name": "0.6.0-alpha.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.5.3",
+  "version": "0.6.0-alpha.2",
   "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`);
-    }
-}