tabctl 0.1.4 → 0.2.1

package/dist/cli/lib/policy-filter.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPolicyFilter = applyPolicyFilter;
+const policy_1 = require("./policy");
+const scope_1 = require("./scope");
+function mapProtectedTab(tab) {
+    return {
+        tabId: tab.tabId,
+        windowId: tab.windowId,
+        groupId: tab.groupId,
+        groupTitle: tab.groupTitle,
+        title: tab.title,
+        url: tab.url,
+        pinned: tab.pinned,
+    };
+}
+function applyPolicyFilter(command, params, snapshot, policyContext, policySummary) {
+    const policy = policyContext.policy;
+    const selection = (0, scope_1.selectTabsFromSnapshot)(snapshot, params);
+    if (selection.error) {
+        return {
+            params,
+            policyInfo: null,
+            earlyResponse: {
+                ok: false,
+                error: selection.error,
+            },
+        };
+    }
+    const selectedTabs = selection.tabs;
+    const eligibleTabs = selectedTabs.filter((tab) => (0, policy_1.evaluateTab)(tab, policy).eligible);
+    const protectedTabs = selectedTabs.filter((tab) => !(0, policy_1.evaluateTab)(tab, policy).eligible);
+    const eligibleIds = eligibleTabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+    let earlyResponse = null;
+    let policyInfo = null;
+    let newParams = params;
+    if (command === "focus" || command === "refresh") {
+        if (!eligibleIds.length) {
+            return {
+                params,
+                policyInfo: null,
+                earlyResponse: {
+                    ok: false,
+                    error: { message: `Tab is protected by policy and cannot be ${command === "focus" ? "focused" : "refreshed"} via CLI` },
+                },
+            };
+        }
+        newParams = {
+            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(mapProtectedTab),
+                    policy: policySummary,
+                },
+            };
+        }
+        else if (command === "close") {
+            newParams = {
+                mode: "direct",
+                confirmed: true,
+                tabIds: eligibleIds,
+            };
+        }
+        else if (command === "archive") {
+            newParams = {
+                tabIds: eligibleIds,
+            };
+        }
+        policyInfo = {
+            protected: protectedTabs.map(mapProtectedTab),
+        };
+    }
+    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(mapProtectedTab),
+                    policy: policySummary,
+                },
+            };
+        }
+        else if (command === "move-tab" || command === "group-assign") {
+            newParams = {
+                ...params,
+                tabId: eligibleIds[0],
+                tabIds: eligibleIds,
+            };
+        }
+        policyInfo = {
+            protected: protectedTabs.map(mapProtectedTab),
+        };
+    }
+    else if (command === "merge-window") {
+        if (!eligibleIds.length) {
+            earlyResponse = {
+                ok: true,
+                action: command,
+                data: {
+                    summary: { eligible: 0, protected: protectedTabs.length },
+                    protected: protectedTabs.map(mapProtectedTab),
+                    policy: policySummary,
+                },
+            };
+        }
+        newParams = {
+            ...params,
+            tabIds: eligibleIds,
+        };
+        policyInfo = {
+            protected: protectedTabs.map(mapProtectedTab),
+        };
+    }
+    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(mapProtectedTab),
+                    policy: policySummary,
+                },
+            };
+        }
+        policyInfo = {
+            protected: protectedTabs.map(mapProtectedTab),
+        };
+    }
+    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 {
+            newParams = {
+                ...params,
+                tabIds: eligibleIds,
+            };
+        }
+    }
+    return {
+        params: newParams,
+        policyInfo,
+        earlyResponse,
+    };
+}

package/dist/cli/lib/response.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotateEntries = annotateEntries;
+exports.annotateCandidates = annotateCandidates;
+exports.buildDedupeOutput = buildDedupeOutput;
+exports.extractDedupePlan = extractDedupePlan;
+exports.formatReport = formatReport;
+exports.writeScreenshots = writeScreenshots;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const report_1 = require("./report");
+const policy_1 = require("./policy");
+const output_1 = require("./output");
+const scope_1 = require("./scope");
+const pagination_1 = require("./pagination");
+const snapshot_1 = require("./snapshot");
+/**
+ * Annotate inspect/report/screenshot entries with policy info and apply pagination.
+ */
+function annotateEntries(data, options, command, policyEnabled, policy, snapshot) {
+    const entries = data.entries;
+    const tabIndex = snapshot ? (0, snapshot_1.buildTabIndex)(snapshot) : null;
+    const annotated = entries.map((entry) => {
+        const tab = tabIndex?.get(entry.tabId) || entry;
+        const { eligible, protectedReasons } = (0, policy_1.evaluateTab)(tab, 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;
+    }
+}
+/**
+ * Annotate analyze candidates with policy info and optional window titles.
+ */
+function annotateCandidates(data, policy, includeWindowTitle, snapshot) {
+    const candidates = data.candidates;
+    const tabIndex = snapshot ? (0, snapshot_1.buildTabIndex)(snapshot) : null;
+    const windowTitleIndex = snapshot && includeWindowTitle
+        ? (0, snapshot_1.buildWindowTitleIndex)(snapshot, policy)
+        : null;
+    data.candidates = candidates.map((candidate) => {
+        const tab = tabIndex?.get(candidate.tabId) || candidate;
+        const { eligible, protectedReasons } = (0, policy_1.evaluateTab)(tab, policy);
+        const windowTitle = includeWindowTitle
+            ? (windowTitleIndex?.get(candidate.windowId) ?? null)
+            : undefined;
+        return {
+            ...candidate,
+            eligible,
+            protectedReasons,
+            ...(includeWindowTitle ? { windowTitle } : {}),
+        };
+    }).filter((candidate) => candidate.eligible !== false);
+}
+/**
+ * Build dedupe output from analyze response, optionally closing tabs.
+ */
+function buildDedupeOutput(response, includeStale, closeData, confirmed) {
+    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;
+        }
+    }
+    const closeSummary = closeData?.summary;
+    const closedTabs = Number(closeSummary?.closedTabs ?? 0);
+    const skippedTabs = Number(closeSummary?.skippedTabs ?? 0);
+    return {
+        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: confirmed
+                ? null
+                : (planTabIds.length > 0 && data.analysisId ? `tabctl close --apply ${data.analysisId} --confirm` : null),
+            policy: data.policy,
+            policyInfo: data.policyInfo,
+        },
+    };
+}
+/**
+ * Extract dedupe plan tab IDs and expected URLs from analyze response.
+ */
+function extractDedupePlan(response, includeStale) {
+    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;
+        }
+    }
+    return { planTabIds, expectedUrls };
+}
+/**
+ * Format report output based on format option.
+ */
+function formatReport(response, options, prettyOutput) {
+    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 { printed: true };
+    }
+    if (format === "json") {
+        (0, output_1.printJson)({ ok: true, data: { format, entries, ...(page ? { page } : {}) } }, prettyOutput);
+        return { printed: true };
+    }
+    (0, output_1.printJson)({ ok: true, data: { format, entries, content, ...(page ? { page } : {}) } }, prettyOutput);
+    return { printed: true };
+}
+/**
+ * Write screenshot tiles to disk and return sanitized output.
+ */
+function writeScreenshots(response, options, prettyOutput) {
+    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 { printed: true };
+}

package/{cli → dist/cli}/lib/scope.js

@@ -8,6 +8,7 @@ exports.selectTabsFromSnapshot = selectTabsFromSnapshot;
 exports.resolveWindowIdFromSnapshot = resolveWindowIdFromSnapshot;
 exports.filterGroupsByScope = filterGroupsByScope;
 const output_1 = require("./output");
+const snapshot_1 = require("./snapshot");
 function formatCliArgValue(value) {
     const raw = String(value);
     if (!raw) {
@@ -104,35 +105,6 @@ function extractScopeParams(options) {
         all: options.all === true,
     };
 }
-// Helper to build window label index (needed by selectTabsFromSnapshot)
-function buildWindowLabelIndex(snapshot) {
-    const windowLabels = new Map();
-    const windows = snapshot.windows || [];
-    windows.forEach((win, index) => {
-        const windowId = win.windowId;
-        if (typeof windowId === "number") {
-            windowLabels.set(windowId, `W${index + 1}`);
-        }
-    });
-    return windowLabels;
-}
-// Helper to list group summaries (needed by selectTabsFromSnapshot)
-function listGroupSummaries(snapshot, windowLabels) {
-    const windows = snapshot.windows || [];
-    const summaries = [];
-    for (const win of windows) {
-        const groups = win.groups || [];
-        for (const group of groups) {
-            summaries.push({
-                windowId: win.windowId,
-                windowLabel: windowLabels.get(win.windowId) ?? null,
-                groupId: group.groupId,
-                title: typeof group.title === "string" ? group.title : null,
-            });
-        }
-    }
-    return summaries;
-}
 function selectTabsFromSnapshot(snapshot, params) {
     const windows = snapshot.windows || [];
     const allTabs = windows.flatMap((win) => win.tabs || []);
@@ -145,7 +117,7 @@ function selectTabsFromSnapshot(snapshot, params) {
         return { tabs: allTabs.filter((tab) => tab.groupId === groupId) };
     }
     if (params.groupTitle) {
-        const windowLabels = buildWindowLabelIndex(snapshot);
+        const windowLabels = (0, snapshot_1.buildWindowLabelIndex)(snapshot);
         const matches = [];
         for (const win of windows) {
             const groups = win.groups || [];
@@ -159,7 +131,7 @@ function selectTabsFromSnapshot(snapshot, params) {
                 }
             }
         }
-        const availableGroups = listGroupSummaries(snapshot, windowLabels);
+        const availableGroups = (0, snapshot_1.listGroupSummaries)(snapshot, windowLabels);
         if (matches.length === 0) {
             return {
                 tabs: [],