tabctl 0.1.0

package/cli/tabctl.js

@@ -0,0 +1,841 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const report_1 = require("./lib/report");
+const policy_1 = require("./lib/policy");
+const constants_1 = require("./lib/constants");
+const output_1 = require("./lib/output");
+const args_1 = require("./lib/args");
+const client_1 = require("./lib/client");
+const scope_1 = require("./lib/scope");
+const pagination_1 = require("./lib/pagination");
+const snapshot_1 = require("./lib/snapshot");
+const help_1 = require("./lib/help");
+const commands_1 = require("./lib/commands");
+const commands_2 = require("./lib/commands");
+const createId = client_1.createRequestId;
+async function main() {
+    (0, output_1.setupStdoutErrorHandling)();
+    let { command, options, warnings } = (0, args_1.parseArgs)(process.argv.slice(2));
+    if (typeof options.profile === "string" && options.profile) {
+        process.env.TABCTL_PROFILE = options.profile;
+    }
+    if (command === "dedupe" && options.close) {
+        (0, output_1.errorOut)("dedupe does not support --close; use --confirm or close --apply <analysisId>.");
+    }
+    const prettyOutput = options.pretty !== false;
+    if (command === "groups" || command === "group") {
+        command = "group-list";
+    }
+    if (command === "profile" || command === "profiles") {
+        command = "profile-list";
+    }
+    if (command === "list" && options.groups === true) {
+        command = "group-list";
+    }
+    if (options.format && command !== "report" && command !== "screenshot") {
+        (0, output_1.errorOut)("Unknown option: --format");
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "policy")) {
+        (0, output_1.errorOut)("Custom policy path is not supported. Use XDG_CONFIG_HOME/tabctl/policy.json.");
+    }
+    if (command === "refresh") {
+        const tabValues = Array.isArray(options.tab)
+            ? options.tab.map((value) => String(value).trim()).filter(Boolean)
+            : [];
+        if (tabValues.length === 0) {
+            (0, output_1.errorOut)("refresh requires --tab");
+        }
+        if (tabValues.length > 1) {
+            (0, output_1.errorOut)("refresh requires a single --tab");
+        }
+    }
+    if (command === "open" && options.color && !options.group) {
+        (0, output_1.errorOut)("--color requires --group");
+    }
+    if (command === "undo") {
+        if (options.txid && options._.length > 0) {
+            (0, output_1.errorOut)("undo requires a single txid (use positional arg or --txid)");
+        }
+        if (options.latest === true && options._.length > 0) {
+            (0, output_1.errorOut)("undo --latest cannot be combined with a txid");
+        }
+        if (options.latest === true && options.txid) {
+            (0, output_1.errorOut)("undo --latest cannot be combined with --txid");
+        }
+        if (options.txid && options._.length === 0) {
+            options._ = [String(options.txid)];
+        }
+    }
+    if (command === "inspect") {
+        const selectorCount = Array.isArray(options.selector) ? options.selector.length : 0;
+        if (selectorCount > 0) {
+            const signalList = (0, args_1.normalizeSignals)(options.signal);
+            if (!signalList.includes("selector")) {
+                signalList.push("selector");
+            }
+            options.signal = signalList;
+        }
+        const signalList = (0, args_1.normalizeSignals)(options.signal);
+        if (signalList.length > 0) {
+            (0, args_1.validateSignals)(signalList);
+            options.signal = signalList;
+        }
+    }
+    if (command === "screenshot") {
+        const mode = options.mode != null ? String(options.mode).trim().toLowerCase() : "viewport";
+        const format = options.format != null ? String(options.format).trim().toLowerCase() : "png";
+        if (mode !== "viewport" && mode !== "full") {
+            (0, output_1.errorOut)("Invalid --mode value (use viewport or full)");
+        }
+        if (format !== "png" && format !== "jpeg") {
+            (0, output_1.errorOut)("Invalid --format value (use png or jpeg)");
+        }
+        if (format === "jpeg" && options.quality == null) {
+            options.quality = 80;
+        }
+        const qualityRaw = options.quality != null ? Number(options.quality) : null;
+        if (qualityRaw != null && (!Number.isFinite(qualityRaw) || qualityRaw < 0 || qualityRaw > 100)) {
+            (0, output_1.errorOut)("Invalid --quality value (use 0-100)");
+        }
+        if (qualityRaw != null && format !== "jpeg") {
+            (0, output_1.errorOut)("--quality requires --format jpeg");
+        }
+        const tileMaxDimRaw = options["tile-max-dim"] != null ? Number(options["tile-max-dim"]) : null;
+        if (tileMaxDimRaw != null && (!Number.isFinite(tileMaxDimRaw) || tileMaxDimRaw <= 0)) {
+            (0, output_1.errorOut)("Invalid --tile-max-dim value");
+        }
+        const maxBytesRaw = options["max-bytes"] != null ? Number(options["max-bytes"]) : null;
+        if (maxBytesRaw != null && (!Number.isFinite(maxBytesRaw) || maxBytesRaw <= 0)) {
+            (0, output_1.errorOut)("Invalid --max-bytes value");
+        }
+        if (mode === "viewport" && options["tile-max-dim"] != null) {
+            (0, output_1.errorOut)("--tile-max-dim requires --mode full");
+        }
+        if (mode === "viewport" && options["max-bytes"] != null) {
+            (0, output_1.errorOut)("--max-bytes requires --mode full");
+        }
+        if (options.mode == null) {
+            options.mode = "viewport";
+        }
+        if (options.format == null) {
+            options.format = "png";
+        }
+    }
+    const policyContext = (0, policy_1.loadPolicy)();
+    const policySummary = (0, policy_1.summarizePolicy)(policyContext.policy, policyContext.path);
+    const policyEnabled = policyContext.policy !== null;
+    const enforcePolicy = policyEnabled;
+    const includeWindowTitle = options["window-title"] === true;
+    const includeStale = options["include-stale"] === true;
+    let policySnapshot = null;
+    const getPolicySnapshot = async () => {
+        if (!policySnapshot) {
+            policySnapshot = await (0, client_1.fetchSnapshot)();
+        }
+        return policySnapshot;
+    };
+    if (!command || command === "help" || options.help) {
+        const helpTarget = command === "help"
+            ? (options._.length > 0 ? String(options._[0]) : undefined)
+            : command;
+        (0, help_1.printHelp)(options.json === true, helpTarget);
+        return;
+    }
+    if (warnings.length > 0) {
+        for (const warning of warnings) {
+            process.stderr.write(`[tabctl] warning: ${warning}\n`);
+        }
+    }
+    if (command === "skill") {
+        (0, commands_1.runSkillInstall)(options, prettyOutput);
+        return;
+    }
+    if (command === "setup") {
+        await (0, commands_1.runSetup)(options, prettyOutput);
+        return;
+    }
+    if (command === "version") {
+        (0, commands_1.runVersion)(prettyOutput);
+        return;
+    }
+    if (command === "policy") {
+        (0, commands_1.runPolicy)(options, policyContext, prettyOutput);
+        return;
+    }
+    if (command === "ping") {
+        await (0, commands_1.runPing)(prettyOutput);
+        return;
+    }
+    if (command === "history") {
+        await (0, commands_1.runHistory)(options, prettyOutput);
+        return;
+    }
+    if (command === "undo") {
+        await (0, commands_1.runUndo)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-list") {
+        (0, commands_1.runProfileList)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-show") {
+        (0, commands_1.runProfileShow)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-switch") {
+        (0, commands_1.runProfileSwitch)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-remove") {
+        (0, commands_1.runProfileRemove)(options, prettyOutput);
+        return;
+    }
+    if (command === "list") {
+        await (0, commands_1.runList)(options, policyContext, policySummary, prettyOutput);
+        return;
+    }
+    if (command === "group-list") {
+        await (0, commands_1.runGroupList)(options, policyContext, policySummary, prettyOutput);
+        return;
+    }
+    let dedupeMode = false;
+    if (command === "close" && options["dry-run"]) {
+        command = "analyze";
+    }
+    if (command === "dedupe") {
+        dedupeMode = true;
+        command = "analyze";
+    }
+    let action = command;
+    let params = {};
+    let policyInfo = null;
+    let earlyResponse = null;
+    switch (command) {
+        case "analyze":
+            action = "analyze";
+            params = (0, commands_2.buildAnalyzeParams)(options);
+            break;
+        case "inspect":
+            action = "inspect";
+            params = (0, commands_2.buildInspectParams)(options);
+            break;
+        case "focus":
+            action = "focus";
+            params = (0, commands_2.buildFocusParams)(options);
+            break;
+        case "refresh":
+            action = "refresh";
+            params = (0, commands_2.buildRefreshParams)(options);
+            break;
+        case "open":
+            action = "open";
+            params = (0, commands_2.buildOpenParams)(options);
+            break;
+        case "group-update":
+            action = "group-update";
+            params = (0, commands_2.buildGroupUpdateParams)(options);
+            break;
+        case "group-ungroup":
+            action = "group-ungroup";
+            params = (0, commands_2.buildGroupUngroupParams)(options);
+            break;
+        case "group-assign":
+            action = "group-assign";
+            params = (0, commands_2.buildGroupAssignParams)(options);
+            break;
+        case "move-tab":
+            action = "move-tab";
+            params = (0, commands_2.buildMoveTabParams)(options);
+            break;
+        case "move-group":
+            action = "move-group";
+            params = (0, commands_2.buildMoveGroupParams)(options);
+            break;
+        case "merge-window":
+            action = "merge-window";
+            params = (0, commands_2.buildMergeWindowParams)(options);
+            break;
+        case "archive":
+            action = "archive";
+            params = (0, commands_2.buildArchiveParams)(options);
+            break;
+        case "close":
+            action = "close";
+            params = (0, commands_2.buildCloseParams)(options);
+            break;
+        case "report":
+            action = "report";
+            params = (0, commands_2.buildReportParams)(options);
+            break;
+        case "screenshot":
+            action = "screenshot";
+            params = (0, commands_2.buildScreenshotParams)(options);
+            break;
+        default:
+            (0, output_1.errorOut)(`Unknown command: ${command}`);
+    }
+    if (command === "analyze") {
+        const tabIds = params.tabIds;
+        const windowId = params.windowId;
+        const hasScope = (Array.isArray(tabIds) && tabIds.length > 0)
+            || Boolean(params.groupTitle)
+            || Number.isFinite(params.groupId)
+            || (typeof windowId === "number" && Number.isFinite(windowId))
+            || (typeof windowId === "string" && windowId.length > 0)
+            || params.all === true;
+        if (!hasScope) {
+            params = { ...params, all: true };
+        }
+    }
+    if (command === "merge-window") {
+        const fromWindowId = params.fromWindowId;
+        const toWindowId = params.toWindowId;
+        if (!Number.isFinite(fromWindowId) || !Number.isFinite(toWindowId)) {
+            (0, output_1.errorOut)("merge-window requires --from and --to window ids");
+        }
+        if (fromWindowId === toWindowId) {
+            (0, output_1.errorOut)("merge-window --from and --to cannot be the same window");
+        }
+        if (params.closeSource && !params.confirmed) {
+            (0, output_1.errorOut)("merge-window --close-source requires --confirm");
+        }
+    }
+    if (enforcePolicy && ["analyze", "inspect", "report", "screenshot", "close", "archive", "focus", "refresh", "move-tab", "move-group", "group-assign", "group-update", "group-ungroup", "merge-window"].includes(command)) {
+        if (command === "close" && options.apply) {
+            (0, output_1.errorOut)("Policy blocks close --apply; use explicit tab targets.");
+        }
+        const snapshot = await getPolicySnapshot();
+        if (!snapshot) {
+            (0, output_1.errorOut)("Failed to load tabs for policy evaluation");
+        }
+        const selection = (0, scope_1.selectTabsFromSnapshot)(snapshot, params);
+        if (selection.error) {
+            (0, output_1.printJson)({ ok: false, error: selection.error }, prettyOutput);
+            process.exit(1);
+        }
+        const selectedTabs = selection.tabs;
+        const eligibleTabs = selectedTabs.filter((tab) => (0, policy_1.evaluateTab)(tab, policyContext.policy).eligible);
+        const protectedTabs = selectedTabs.filter((tab) => !(0, policy_1.evaluateTab)(tab, policyContext.policy).eligible);
+        const eligibleIds = eligibleTabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+        if (command === "focus" || command === "refresh") {
+            if (!eligibleIds.length) {
+                (0, output_1.errorOut)(`Tab is protected by policy and cannot be ${command === "focus" ? "focused" : "refreshed"} via CLI`);
+            }
+            params = {
+                tabId: eligibleIds[0],
+            };
+        }
+        else if (command === "close" || command === "archive") {
+            if (!eligibleIds.length) {
+                earlyResponse = {
+                    ok: true,
+                    action: command,
+                    data: {
+                        summary: { eligible: 0, protected: protectedTabs.length },
+                        protected: protectedTabs.map((tab) => ({
+                            tabId: tab.tabId,
+                            windowId: tab.windowId,
+                            groupId: tab.groupId,
+                            groupTitle: tab.groupTitle,
+                            title: tab.title,
+                            url: tab.url,
+                            pinned: tab.pinned,
+                        })),
+                        policy: policySummary,
+                    },
+                };
+            }
+            else if (command === "close") {
+                params = {
+                    mode: "direct",
+                    confirmed: true,
+                    tabIds: eligibleIds,
+                };
+            }
+            else if (command === "archive") {
+                params = {
+                    tabIds: eligibleIds,
+                };
+            }
+            policyInfo = {
+                protected: protectedTabs.map((tab) => ({
+                    tabId: tab.tabId,
+                    windowId: tab.windowId,
+                    groupId: tab.groupId,
+                    groupTitle: tab.groupTitle,
+                    title: tab.title,
+                    url: tab.url,
+                    pinned: tab.pinned,
+                })),
+            };
+        }
+        else if (command === "move-tab" || command === "move-group" || command === "group-assign") {
+            if (!eligibleIds.length || (command === "move-group" && protectedTabs.length > 0)) {
+                earlyResponse = {
+                    ok: true,
+                    action: command,
+                    data: {
+                        summary: { eligible: eligibleIds.length, protected: protectedTabs.length },
+                        protected: protectedTabs.map((tab) => ({
+                            tabId: tab.tabId,
+                            windowId: tab.windowId,
+                            groupId: tab.groupId,
+                            groupTitle: tab.groupTitle,
+                            title: tab.title,
+                            url: tab.url,
+                            pinned: tab.pinned,
+                        })),
+                        policy: policySummary,
+                    },
+                };
+            }
+            else if (command === "move-tab" || command === "group-assign") {
+                params = {
+                    ...params,
+                    tabId: eligibleIds[0],
+                    tabIds: eligibleIds,
+                };
+            }
+            policyInfo = {
+                protected: protectedTabs.map((tab) => ({
+                    tabId: tab.tabId,
+                    windowId: tab.windowId,
+                    groupId: tab.groupId,
+                    groupTitle: tab.groupTitle,
+                    title: tab.title,
+                    url: tab.url,
+                    pinned: tab.pinned,
+                })),
+            };
+        }
+        else if (command === "merge-window") {
+            if (!eligibleIds.length) {
+                earlyResponse = {
+                    ok: true,
+                    action: command,
+                    data: {
+                        summary: { eligible: 0, protected: protectedTabs.length },
+                        protected: protectedTabs.map((tab) => ({
+                            tabId: tab.tabId,
+                            windowId: tab.windowId,
+                            groupId: tab.groupId,
+                            groupTitle: tab.groupTitle,
+                            title: tab.title,
+                            url: tab.url,
+                            pinned: tab.pinned,
+                        })),
+                        policy: policySummary,
+                    },
+                };
+            }
+            params = {
+                ...params,
+                tabIds: eligibleIds,
+            };
+            policyInfo = {
+                protected: protectedTabs.map((tab) => ({
+                    tabId: tab.tabId,
+                    windowId: tab.windowId,
+                    groupId: tab.groupId,
+                    groupTitle: tab.groupTitle,
+                    title: tab.title,
+                    url: tab.url,
+                    pinned: tab.pinned,
+                })),
+            };
+        }
+        else if (command === "group-update" || command === "group-ungroup") {
+            if (!eligibleIds.length || protectedTabs.length > 0) {
+                earlyResponse = {
+                    ok: true,
+                    action: command,
+                    data: {
+                        summary: { eligible: eligibleIds.length, protected: protectedTabs.length },
+                        protected: protectedTabs.map((tab) => ({
+                            tabId: tab.tabId,
+                            windowId: tab.windowId,
+                            groupId: tab.groupId,
+                            groupTitle: tab.groupTitle,
+                            title: tab.title,
+                            url: tab.url,
+                            pinned: tab.pinned,
+                        })),
+                        policy: policySummary,
+                    },
+                };
+            }
+            policyInfo = {
+                protected: protectedTabs.map((tab) => ({
+                    tabId: tab.tabId,
+                    windowId: tab.windowId,
+                    groupId: tab.groupId,
+                    groupTitle: tab.groupTitle,
+                    title: tab.title,
+                    url: tab.url,
+                    pinned: tab.pinned,
+                })),
+            };
+        }
+        else {
+            if (!eligibleIds.length) {
+                const generatedAt = Date.now();
+                if (command === "analyze") {
+                    earlyResponse = {
+                        ok: true,
+                        action: command,
+                        data: {
+                            generatedAt,
+                            staleDays: params.staleDays || 0,
+                            totals: { tabs: 0, analyzed: 0, candidates: 0 },
+                            meta: { durationMs: 0, githubChecked: 0, githubTotal: 0, githubMatched: 0, githubTimeoutMs: params.githubTimeoutMs || 0 },
+                            candidates: [],
+                            analysisId: null,
+                            policy: policySummary,
+                        },
+                    };
+                }
+                else if (command === "screenshot") {
+                    earlyResponse = {
+                        ok: true,
+                        action: command,
+                        data: {
+                            generatedAt,
+                            entries: [],
+                            totals: { tabs: 0, tiles: 0 },
+                            meta: {
+                                durationMs: 0,
+                                mode: params.mode || "viewport",
+                                format: params.format || "png",
+                                tileMaxDim: params.tileMaxDim || null,
+                                maxBytes: params.maxBytes || null,
+                            },
+                            policy: policySummary,
+                        },
+                    };
+                }
+                else {
+                    earlyResponse = {
+                        ok: true,
+                        action: command,
+                        data: {
+                            generatedAt,
+                            entries: [],
+                            totals: { tabs: 0, signals: 0, tasks: 0 },
+                            meta: { durationMs: 0, signalTimeoutMs: params.signalTimeoutMs || 0, selectorCount: 0 },
+                            policy: policySummary,
+                        },
+                    };
+                }
+            }
+            else {
+                params = {
+                    ...params,
+                    tabIds: eligibleIds,
+                };
+            }
+        }
+    }
+    const request = {
+        id: createId(),
+        action,
+        params,
+        client: {
+            component: "cli",
+            version: constants_1.VERSION,
+            baseVersion: constants_1.BASE_VERSION,
+            gitSha: constants_1.GIT_SHA,
+            dirty: constants_1.DIRTY,
+        },
+    };
+    let response;
+    const showProgress = options.progress === true;
+    const startedAt = Date.now();
+    let progressTimer = null;
+    if (showProgress) {
+        progressTimer = setInterval(() => {
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            process.stderr.write(`[tabctl] waiting ${elapsed}s...\n`);
+        }, 2000);
+    }
+    const onProgress = showProgress
+        ? (message) => {
+            const data = message.data;
+            if (data?.phase === "github") {
+                const processed = data.processed;
+                const total = data.total;
+                const matched = data.matched;
+                process.stderr.write(`[tabctl] github ${processed}/${total} (matched ${matched})\n`);
+            }
+            if (data?.phase === "inspect") {
+                const processed = data.processed;
+                const total = data.total;
+                const signalId = data.signalId;
+                process.stderr.write(`[tabctl] inspect ${processed}/${total} (${signalId})\n`);
+            }
+            if (data?.phase === "screenshot") {
+                const processed = data.processed;
+                const total = data.total;
+                process.stderr.write(`[tabctl] screenshot ${processed}/${total}\n`);
+            }
+        }
+        : undefined;
+    if (earlyResponse) {
+        response = earlyResponse;
+    }
+    else {
+        try {
+            response = await (0, client_1.sendRequest)(request, onProgress);
+        }
+        catch (error) {
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+            const message = error instanceof Error ? error.message : "Unknown error";
+            (0, output_1.errorOut)(`Failed to connect to host: ${message}`);
+            return;
+        }
+        finally {
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+        }
+    }
+    if (progressTimer) {
+        clearInterval(progressTimer);
+    }
+    if (!response) {
+        (0, output_1.errorOut)("No response received");
+    }
+    if (!response.ok) {
+        (0, output_1.printJson)(response, prettyOutput);
+        process.exit(1);
+    }
+    if (response.data && typeof response.data === "object") {
+        const data = response.data;
+        if ((command === "inspect" || command === "report" || command === "screenshot") && Array.isArray(data.entries)) {
+            let snapshot = null;
+            if (policyEnabled) {
+                snapshot = await getPolicySnapshot();
+            }
+            const tabIndex = snapshot ? (0, snapshot_1.buildTabIndex)(snapshot) : null;
+            const annotated = data.entries.map((entry) => {
+                const tab = tabIndex?.get(entry.tabId) || entry;
+                const { eligible, protectedReasons } = (0, policy_1.evaluateTab)(tab, policyContext.policy);
+                return {
+                    ...entry,
+                    eligible,
+                    protectedReasons,
+                };
+            }).filter((entry) => entry.eligible !== false);
+            const scope = (0, scope_1.resolveScopeFlags)(options);
+            const allScope = options.all === true || !scope.hasScope;
+            const scopeArgs = (0, scope_1.buildScopeArgs)(options, allScope);
+            const pagination = (0, pagination_1.resolvePagination)(options, annotated.length, command, scopeArgs);
+            const start = pagination.offset;
+            const end = pagination.offset + pagination.limit;
+            data.entries = annotated.slice(start, end);
+            if (pagination.page) {
+                data.page = pagination.page;
+            }
+        }
+        if (command === "analyze" && Array.isArray(data.candidates)) {
+            let snapshot = null;
+            if (policyEnabled || includeWindowTitle) {
+                snapshot = await getPolicySnapshot();
+            }
+            const tabIndex = snapshot ? (0, snapshot_1.buildTabIndex)(snapshot) : null;
+            const windowTitleIndex = snapshot && includeWindowTitle
+                ? (0, snapshot_1.buildWindowTitleIndex)(snapshot, policyContext.policy)
+                : null;
+            data.candidates = data.candidates.map((candidate) => {
+                const tab = tabIndex?.get(candidate.tabId) || candidate;
+                const { eligible, protectedReasons } = (0, policy_1.evaluateTab)(tab, policyContext.policy);
+                const windowTitle = includeWindowTitle
+                    ? (windowTitleIndex?.get(candidate.windowId) ?? null)
+                    : undefined;
+                return {
+                    ...candidate,
+                    eligible,
+                    protectedReasons,
+                    ...(includeWindowTitle ? { windowTitle } : {}),
+                };
+            }).filter((candidate) => candidate.eligible !== false);
+        }
+        data.policy = policySummary;
+        if (policyInfo) {
+            data.policyInfo = policyInfo;
+        }
+    }
+    else if (response.ok) {
+        response.policy = policySummary;
+    }
+    if (dedupeMode) {
+        if (!response.ok) {
+            (0, output_1.printJson)(response, prettyOutput);
+            return;
+        }
+        const data = response.data || {};
+        const candidates = Array.isArray(data.candidates) ? data.candidates : [];
+        const planned = candidates.filter((candidate) => {
+            const reasons = Array.isArray(candidate.reasons) ? candidate.reasons : [];
+            const hasDuplicate = reasons.some((reason) => reason.type === "duplicate" || reason.type === "closed_issue");
+            const hasStale = reasons.some((reason) => reason.type === "stale");
+            return hasDuplicate || (includeStale && hasStale);
+        });
+        const planTabIds = [];
+        const expectedUrls = {};
+        for (const candidate of planned) {
+            const tabId = candidate.tabId;
+            if (!Number.isFinite(tabId)) {
+                continue;
+            }
+            if (!planTabIds.includes(tabId)) {
+                planTabIds.push(tabId);
+            }
+            if (typeof candidate.url === "string") {
+                expectedUrls[String(tabId)] = candidate.url;
+            }
+        }
+        let closeData = null;
+        if (options.confirm === true && planTabIds.length > 0) {
+            const closeResponse = await (0, client_1.sendRequest)({
+                id: createId(),
+                action: "close",
+                params: {
+                    mode: "direct",
+                    confirmed: true,
+                    tabIds: planTabIds,
+                    expectedUrls,
+                },
+            });
+            if (!closeResponse.ok) {
+                (0, output_1.printJson)(closeResponse, prettyOutput);
+                return;
+            }
+            closeData = closeResponse.data || {};
+            closeData.policy = policySummary;
+            if (policyInfo) {
+                closeData.policyInfo = policyInfo;
+            }
+        }
+        const closeSummary = closeData?.summary;
+        const closedTabs = Number(closeSummary?.closedTabs ?? 0);
+        const skippedTabs = Number(closeSummary?.skippedTabs ?? 0);
+        const output = {
+            ok: true,
+            action: "dedupe",
+            data: {
+                analysisId: data.analysisId || null,
+                summary: {
+                    candidates: candidates.length,
+                    planned: planTabIds.length,
+                    closed: Number.isFinite(closedTabs) ? closedTabs : 0,
+                    skipped: Number.isFinite(skippedTabs) ? skippedTabs : 0,
+                },
+                plan: {
+                    tabIds: planTabIds,
+                    candidates: planned,
+                },
+                close: closeData,
+                nextCommand: options.confirm === true
+                    ? null
+                    : (planTabIds.length > 0 && data.analysisId ? `tabctl close --apply ${data.analysisId} --confirm` : null),
+                policy: data.policy,
+                policyInfo: data.policyInfo,
+            },
+        };
+        (0, output_1.printJson)(output, prettyOutput);
+        return;
+    }
+    if (command === "report") {
+        const format = options.format || "json";
+        const data = response.data;
+        const entries = data?.entries || [];
+        const generatedAt = data?.generatedAt;
+        const page = data && "page" in data ? data.page : undefined;
+        let content = "";
+        if (format === "json") {
+            content = JSON.stringify({ generatedAt, entries }, null, 2);
+        }
+        else if (format === "csv") {
+            content = (0, report_1.renderCsv)(entries);
+        }
+        else if (format === "md") {
+            content = (0, report_1.renderMarkdown)(entries, generatedAt);
+        }
+        else {
+            (0, output_1.errorOut)(`Unknown report format: ${format}`);
+        }
+        if (options.out) {
+            fs_1.default.writeFileSync(String(options.out), content, "utf8");
+            (0, output_1.printJson)({ ok: true, data: { writtenTo: options.out, format, count: entries.length, ...(page ? { page } : {}) } }, prettyOutput);
+            return;
+        }
+        if (format === "json") {
+            (0, output_1.printJson)({ ok: true, data: { format, entries, ...(page ? { page } : {}) } }, prettyOutput);
+            return;
+        }
+        (0, output_1.printJson)({ ok: true, data: { format, entries, content, ...(page ? { page } : {}) } }, prettyOutput);
+        return;
+    }
+    if (command === "screenshot") {
+        const data = response.data;
+        const entries = data?.entries || [];
+        const page = data && "page" in data ? data.page : undefined;
+        const outDir = options.out
+            ? String(options.out)
+            : path_1.default.join(process.cwd(), ".tabctl", "screenshots", String(Date.now()));
+        fs_1.default.mkdirSync(outDir, { recursive: true });
+        let filesWritten = 0;
+        const sanitized = entries.map((entry) => {
+            const tabId = entry.tabId;
+            const tabDir = path_1.default.join(outDir, String(tabId ?? "unknown"));
+            fs_1.default.mkdirSync(tabDir, { recursive: true });
+            const tiles = Array.isArray(entry.tiles) ? entry.tiles : [];
+            const sanitizedTiles = tiles.map((tile) => {
+                const rawUrl = tile.dataUrl;
+                const { dataUrl: _ignored, ...rest } = tile;
+                if (!rawUrl) {
+                    return { ...rest, path: null, error: "missing_data" };
+                }
+                const match = rawUrl.match(/^data:(image\/png|image\/jpeg);base64,(.+)$/);
+                if (!match) {
+                    return { ...rest, path: null, error: "invalid_data_url" };
+                }
+                const mime = match[1];
+                const base64 = match[2];
+                const ext = mime === "image/jpeg" ? "jpg" : "png";
+                const index = Number.isFinite(tile.index) ? Number(tile.index) + 1 : filesWritten + 1;
+                const total = Number.isFinite(tile.total) ? Number(tile.total) : null;
+                const suffix = total && total > 1 ? `-of-${total}` : "";
+                const filename = `screenshot-${index}${suffix}.${ext}`;
+                const filePath = path_1.default.join(tabDir, filename);
+                const buffer = Buffer.from(base64, "base64");
+                fs_1.default.writeFileSync(filePath, buffer);
+                filesWritten += 1;
+                return {
+                    ...rest,
+                    path: filePath,
+                    bytes: buffer.length,
+                };
+            });
+            return {
+                ...entry,
+                tiles: sanitizedTiles,
+            };
+        });
+        (0, output_1.printJson)({ ok: true, data: { writtenTo: outDir, files: filesWritten, entries: sanitized, ...(page ? { page } : {}) } }, prettyOutput);
+        return;
+    }
+    (0, output_1.emitVersionWarnings)(response, command);
+    (0, output_1.printJson)(response, prettyOutput);
+}
+main().catch((error) => {
+    (0, output_1.errorOut)(error.message || "Unknown error");
+});