tabctl 0.3.0 → 0.4.0

package/dist/extension/lib/groups.js

@@ -11,10 +11,15 @@ exports.listGroups = listGroups;
 exports.groupUpdate = groupUpdate;
 exports.groupUngroup = groupUngroup;
 exports.groupAssign = groupAssign;
+exports.groupGather = groupGather;
 function getGroupTabs(windowSnapshot, groupId) {
     return windowSnapshot.tabs
         .filter((tab) => tab.groupId === groupId)
-        .sort((a, b) => (Number(a.index) || 0) - (Number(b.index) || 0));
+        .sort((a, b) => {
+        const ai = Number(a.index);
+        const bi = Number(b.index);
+        return (Number.isFinite(ai) ? ai : 0) - (Number.isFinite(bi) ? bi : 0);
+    });
 }
 function listGroupSummaries(snapshot, buildWindowLabels, windowId) {
     const windowLabels = buildWindowLabels(snapshot);
@@ -83,8 +88,8 @@ function resolveGroupByTitle(snapshot, buildWindowLabels, groupTitle, windowId)
     if (matches.length > 1) {
         return {
             error: {
-                message: "Group title is ambiguous. Provide a windowId.",
-                hint: "Use --window to disambiguate group titles.",
+                message: `Ambiguous group title: found ${matches.length} groups named "${groupTitle}". Use group-gather to merge duplicates, --group-id to target by ID, or --window to narrow scope.`,
+                hint: "Use group-gather to merge duplicates, --group-id to target by ID, or --window to narrow scope.",
                 matches: matches.map((match) => summarizeGroupMatch(match, windowLabels)),
                 availableGroups,
             },
@@ -441,3 +446,84 @@ async function groupAssign(params, deps) {
         txid: params.txid || null,
     };
 }
+async function groupGather(params, deps) {
+    const snapshot = await deps.getTabSnapshot();
+    const windows = snapshot.windows;
+    const windowIdParam = params.windowId != null ? deps.resolveWindowIdFromParams(snapshot, params.windowId) : null;
+    if (windowIdParam && !windows.some((win) => win.windowId === windowIdParam)) {
+        throw new Error("Window not found");
+    }
+    const groupTitleFilter = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+    const merged = [];
+    const undoEntries = [];
+    for (const win of windows) {
+        if (windowIdParam && win.windowId !== windowIdParam)
+            continue;
+        const byTitle = new Map();
+        for (const group of win.groups) {
+            const title = typeof group.title === "string" ? group.title : "";
+            if (!title)
+                continue;
+            if (groupTitleFilter && title !== groupTitleFilter)
+                continue;
+            if (!byTitle.has(title))
+                byTitle.set(title, []);
+            byTitle.get(title).push(group);
+        }
+        for (const [title, titleGroups] of byTitle) {
+            if (titleGroups.length < 2)
+                continue;
+            const groupsWithIndex = titleGroups.map((g) => {
+                const tabs = win.tabs.filter((t) => t.groupId === g.groupId);
+                const minIndex = Math.min(...tabs.map((t) => {
+                    const idx = Number(t.index);
+                    return Number.isFinite(idx) ? idx : Infinity;
+                }));
+                return { group: g, tabs, minIndex };
+            });
+            groupsWithIndex.sort((a, b) => a.minIndex - b.minIndex);
+            const primary = groupsWithIndex[0];
+            const duplicates = groupsWithIndex.slice(1);
+            let movedTabs = 0;
+            for (const dup of duplicates) {
+                const tabIds = dup.tabs
+                    .map((t) => t.tabId)
+                    .filter((id) => typeof id === "number");
+                if (tabIds.length > 0) {
+                    for (const tab of dup.tabs) {
+                        undoEntries.push({
+                            tabId: tab.tabId,
+                            windowId: win.windowId,
+                            index: tab.index,
+                            groupId: tab.groupId,
+                            groupTitle: tab.groupTitle,
+                            groupColor: tab.groupColor,
+                            groupCollapsed: dup.group.collapsed ?? null,
+                        });
+                    }
+                    await chrome.tabs.group({ groupId: primary.group.groupId, tabIds });
+                    movedTabs += tabIds.length;
+                }
+            }
+            merged.push({
+                windowId: win.windowId,
+                groupTitle: title,
+                primaryGroupId: primary.group.groupId,
+                mergedGroupCount: duplicates.length,
+                movedTabs,
+            });
+        }
+    }
+    return {
+        merged,
+        summary: {
+            mergedGroups: merged.reduce((sum, m) => sum + m.mergedGroupCount, 0),
+            movedTabs: merged.reduce((sum, m) => sum + m.movedTabs, 0),
+        },
+        undo: {
+            action: "group-gather",
+            tabs: undoEntries,
+        },
+        txid: params.txid || null,
+    };
+}

package/dist/extension/lib/screenshot.js

@@ -15,7 +15,7 @@ exports.scrollToPosition = scrollToPosition;
 exports.captureTabTiles = captureTabTiles;
 exports.screenshotTabs = screenshotTabs;
 exports.SCREENSHOT_TILE_MAX_DIM = 2000;
-exports.SCREENSHOT_MAX_BYTES = 2000000;
+exports.SCREENSHOT_MAX_BYTES = 2_000_000;
 exports.SCREENSHOT_QUALITY = 80;
 exports.SCREENSHOT_SCROLL_DELAY_MS = 150;
 exports.SCREENSHOT_CAPTURE_DELAY_MS = 350;
@@ -288,7 +288,7 @@ async function screenshotTabs(params, requestId, deps) {
     const adjustedTileMaxDim = tileMaxDim < 50 ? 50 : tileMaxDim;
     const maxBytesRaw = Number(params.maxBytes);
     const maxBytes = Number.isFinite(maxBytesRaw) && maxBytesRaw > 0 ? Math.floor(maxBytesRaw) : exports.SCREENSHOT_MAX_BYTES;
-    const adjustedMaxBytes = maxBytes < 50000 ? 50000 : maxBytes;
+    const adjustedMaxBytes = maxBytes < 50_000 ? 50_000 : maxBytes;
     const progressEnabled = params.progress === true;
     const tabs = selection.tabs;
     const entries = [];

package/dist/extension/lib/tabs.js

@@ -1,5 +1,8 @@
 "use strict";
 // Tab operations — extracted from background.ts (pure structural refactor).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMostRecentFocusedWindowId = getMostRecentFocusedWindowId;
 exports.normalizeUrl = normalizeUrl;
@@ -8,6 +11,7 @@ exports.resolveOpenWindow = resolveOpenWindow;
 exports.focusTab = focusTab;
 exports.refreshTabs = refreshTabs;
 exports.openTabs = openTabs;
+const normalize_url_1 = __importDefault(require("normalize-url"));
 function getMostRecentFocusedWindowId(windows) {
     let bestWindowId = null;
     let bestFocusedAt = -Infinity;
@@ -29,42 +33,26 @@ function normalizeUrl(rawUrl) {
     if (!rawUrl || typeof rawUrl !== "string") {
         return null;
     }
-    let url;
     try {
-        url = new URL(rawUrl);
+        return (0, normalize_url_1.default)(rawUrl, {
+            stripHash: true,
+            removeQueryParameters: [
+                /^utm_\w+$/i,
+                "fbclid",
+                "gclid",
+                "igshid",
+                "mc_cid",
+                "mc_eid",
+                "ref",
+                "ref_src",
+                "ref_url",
+                "si",
+            ],
+        });
     }
     catch {
         return null;
     }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        return null;
-    }
-    url.hash = "";
-    const dropKeys = new Set([
-        "fbclid",
-        "gclid",
-        "igshid",
-        "mc_cid",
-        "mc_eid",
-        "ref",
-        "ref_src",
-        "ref_url",
-        "utm_campaign",
-        "utm_content",
-        "utm_medium",
-        "utm_source",
-        "utm_term",
-        "utm_name",
-        "si",
-    ]);
-    for (const key of Array.from(url.searchParams.keys())) {
-        if (key.startsWith("utm_") || dropKeys.has(key)) {
-            url.searchParams.delete(key);
-        }
-    }
-    const search = url.searchParams.toString();
-    url.search = search ? `?${search}` : "";
-    return url.toString();
 }
 function normalizeTabIndex(value) {
     const index = Number(value);
@@ -200,6 +188,8 @@ async function openTabs(params, deps) {
         throw new Error("Only one target position is allowed");
     }
     const newWindow = params.newWindow === true;
+    const forceNewGroup = params.newGroup === true;
+    const allowDuplicates = params.allowDuplicates === true;
     if (!urls.length && !newWindow) {
         throw new Error("No URLs provided");
     }
@@ -287,6 +277,13 @@ async function openTabs(params, deps) {
     }
     const snapshot = await deps.getTabSnapshot();
     let openParams = params;
+    // Auto-resolve window by group name when no explicit window selector is provided
+    if (groupTitle && !forceNewGroup && openParams.windowId == null && !openParams.windowGroupTitle && !openParams.windowTabId && !openParams.windowUrl) {
+        const groupWindows = snapshot.windows.filter((win) => win.groups.some((g) => g.title === groupTitle));
+        if (groupWindows.length === 1) {
+            openParams = { ...openParams, windowId: groupWindows[0].windowId };
+        }
+    }
     if (params.windowId == null && (beforeTabId != null || afterTabId != null)) {
         const anchorId = beforeTabId != null ? beforeTabId : afterTabId;
         const anchorWindow = snapshot.windows
@@ -304,6 +301,25 @@ async function openTabs(params, deps) {
     if (!windowSnapshot) {
         throw new Error("Window snapshot unavailable");
     }
+    // Resolve existing group for reuse
+    let existingGroupId = null;
+    const existingUrlSet = new Set();
+    if (groupTitle && !forceNewGroup) {
+        const matchingGroups = windowSnapshot.groups.filter((g) => g.title === groupTitle);
+        if (matchingGroups.length > 1) {
+            throw new Error(`Ambiguous group title "${groupTitle}": found ${matchingGroups.length} groups with the same name. Use --new-group to force a new group, group-gather to merge, or --group-id to target by ID.`);
+        }
+        if (matchingGroups.length === 1) {
+            existingGroupId = matchingGroups[0].groupId;
+            const existingTabs = windowSnapshot.tabs.filter((tab) => tab.groupId === existingGroupId);
+            for (const tab of existingTabs) {
+                const norm = normalizeUrl(tab.url);
+                if (norm) {
+                    existingUrlSet.add(norm);
+                }
+            }
+        }
+    }
     const created = [];
     const skipped = [];
     let insertIndex = null;
@@ -339,8 +355,25 @@ async function openTabs(params, deps) {
         }
         insertIndex = beforeTabId != null ? anchorIndex : anchorIndex + 1;
     }
+    // Default insert position: append after existing group tabs
+    if (existingGroupId != null && insertIndex == null && beforeTabId == null && afterTabId == null) {
+        const groupTabs = windowSnapshot.tabs.filter((tab) => tab.groupId === existingGroupId);
+        const indices = groupTabs
+            .map((tab) => normalizeTabIndex(tab.index))
+            .filter((value) => value != null);
+        if (indices.length) {
+            insertIndex = Math.max(...indices) + 1;
+        }
+    }
     let nextIndex = insertIndex;
     for (const url of urls) {
+        if (!allowDuplicates && existingGroupId != null) {
+            const norm = normalizeUrl(url);
+            if (norm && existingUrlSet.has(norm)) {
+                skipped.push({ url, reason: "duplicate" });
+                continue;
+            }
+        }
         try {
             const createOptions = { windowId, url, active: false };
             if (nextIndex != null) {
@@ -365,12 +398,18 @@ async function openTabs(params, deps) {
         try {
             const tabIds = created.map((tab) => tab.tabId).filter((id) => typeof id === "number");
             if (tabIds.length > 0) {
-                groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId } });
-                const update = { title: groupTitle };
-                if (groupColor) {
-                    update.color = groupColor;
+                if (existingGroupId != null) {
+                    // Reuse existing group
+                    groupId = await chrome.tabs.group({ groupId: existingGroupId, tabIds });
+                }
+                else {
+                    groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId } });
+                    const update = { title: groupTitle };
+                    if (groupColor) {
+                        update.color = groupColor;
+                    }
+                    await chrome.tabGroups.update(groupId, update);
                 }
-                await chrome.tabGroups.update(groupId, update);
             }
         }
         catch (error) {
@@ -378,6 +417,28 @@ async function openTabs(params, deps) {
             groupId = null;
         }
     }
+    // All-dupes case: report existing group even when no new tabs were created
+    if (groupTitle && created.length === 0 && existingGroupId != null) {
+        groupId = existingGroupId;
+    }
+    // Reorder: groups before ungrouped tabs
+    try {
+        const freshTabs = await chrome.tabs.query({ windowId });
+        freshTabs.sort((a, b) => a.index - b.index);
+        const firstUngroupedIndex = freshTabs.findIndex(t => (t.groupId ?? -1) === -1);
+        if (firstUngroupedIndex >= 0) {
+            const groupedAfterUngrouped = freshTabs.filter((t, i) => i > firstUngroupedIndex && (t.groupId ?? -1) !== -1);
+            if (groupedAfterUngrouped.length > 0) {
+                const tabIdsToMove = groupedAfterUngrouped.map(t => t.id).filter(id => typeof id === "number");
+                if (tabIdsToMove.length > 0) {
+                    await chrome.tabs.move(tabIdsToMove, { index: firstUngroupedIndex });
+                }
+            }
+        }
+    }
+    catch (err) {
+        deps.log("Failed to reorder groups before ungrouped tabs", err);
+    }
     return {
         windowId,
         groupId,

package/dist/extension/lib/undo-handlers.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.undoGroupUpdate = undoGroupUpdate;
 exports.undoGroupUngroup = undoGroupUngroup;
 exports.undoGroupAssign = undoGroupAssign;
+exports.undoGroupGather = undoGroupGather;
 exports.undoMoveTab = undoMoveTab;
 exports.undoMoveGroup = undoMoveGroup;
 exports.undoMergeWindow = undoMergeWindow;
@@ -197,6 +198,10 @@ async function undoGroupAssign(undo, deps) {
     const tabs = undo.tabs || [];
     return await restoreTabsFromUndo(tabs, deps);
 }
+async function undoGroupGather(undo, deps) {
+    const tabs = undo.tabs || [];
+    return await restoreTabsFromUndo(tabs, deps);
+}
 async function undoMoveTab(undo, deps) {
     const from = undo.from || {};
     const entry = {
@@ -426,6 +431,9 @@ async function undoTransaction(params, deps) {
     if (undo.action === "group-assign") {
         return await undoGroupAssign(undo, deps);
     }
+    if (undo.action === "group-gather") {
+        return await undoGroupGather(undo, deps);
+    }
     if (undo.action === "move-tab") {
         return await undoMoveTab(undo, deps);
     }

package/dist/extension/manifest.json

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