tabctl 0.1.4 → 0.2.1

package/dist/extension/lib/inspect.js

@@ -0,0 +1,316 @@
+"use strict";
+// Analysis/inspection pipeline — extracted from tabs.ts (pure structural refactor).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECTOR_VALUE_MAX_LENGTH = exports.DESCRIPTION_MAX_LENGTH = exports.DEFAULT_STALE_DAYS = void 0;
+exports.analyzeTabs = analyzeTabs;
+exports.inspectTabs = inspectTabs;
+const content = require("./content");
+const { isScriptableUrl, isGitHubIssueOrPr, detectGitHubState, extractPageMeta, extractSelectorSignal, waitForSettle, waitForTabReady } = content;
+const tabs = require("./tabs");
+const { normalizeUrl } = tabs;
+exports.DEFAULT_STALE_DAYS = 30;
+exports.DESCRIPTION_MAX_LENGTH = 250;
+exports.SELECTOR_VALUE_MAX_LENGTH = 500;
+async function analyzeTabs(params, requestId, deps) {
+    const staleDays = Number.isFinite(params.staleDays) ? params.staleDays : exports.DEFAULT_STALE_DAYS;
+    const checkGitHub = params.checkGitHub === true;
+    const githubConcurrencyRaw = Number(params.githubConcurrency);
+    const githubConcurrency = Number.isFinite(githubConcurrencyRaw) && githubConcurrencyRaw > 0
+        ? Math.min(10, Math.floor(githubConcurrencyRaw))
+        : 4;
+    const githubTimeoutRaw = Number(params.githubTimeoutMs);
+    const githubTimeoutMs = Number.isFinite(githubTimeoutRaw) && githubTimeoutRaw > 0
+        ? Math.floor(githubTimeoutRaw)
+        : 4000;
+    const progressEnabled = params.progress === true;
+    const snapshot = await deps.getTabSnapshot();
+    const selection = deps.selectTabsByScope(snapshot, params);
+    if (selection.error) {
+        throw selection.error;
+    }
+    const selectedTabs = selection.tabs;
+    const scopeTabs = selectedTabs;
+    const now = Date.now();
+    const startedAt = Date.now();
+    let githubChecked = 0;
+    let githubTotal = 0;
+    let githubMatched = 0;
+    const normalizedMap = new Map();
+    const duplicates = new Map();
+    for (const tab of scopeTabs) {
+        const normalized = normalizeUrl(tab.url);
+        if (!normalized) {
+            continue;
+        }
+        if (normalizedMap.has(normalized)) {
+            const existing = normalizedMap.get(normalized);
+            duplicates.set(tab.tabId, existing.tabId);
+        }
+        else {
+            normalizedMap.set(normalized, tab);
+        }
+    }
+    const candidateMap = new Map();
+    const addReason = (tab, reason) => {
+        const tabId = tab.tabId;
+        const entry = candidateMap.get(tabId) || { tab, reasons: [] };
+        entry.reasons.push(reason);
+        candidateMap.set(tabId, entry);
+    };
+    for (const tab of selectedTabs) {
+        if (duplicates.has(tab.tabId)) {
+            addReason(tab, {
+                type: "duplicate",
+                detail: `Matches tab ${duplicates.get(tab.tabId)}`,
+            });
+        }
+        if (tab.lastFocusedAt) {
+            const ageDays = (now - tab.lastFocusedAt) / (24 * 60 * 60 * 1000);
+            if (ageDays >= staleDays) {
+                addReason(tab, {
+                    type: "stale",
+                    detail: `Last focused ${Math.floor(ageDays)} days ago`,
+                });
+            }
+        }
+    }
+    const githubTabs = checkGitHub
+        ? selectedTabs.filter((tab) => isGitHubIssueOrPr(tab.url) && isScriptableUrl(tab.url))
+        : [];
+    githubTotal = githubTabs.length;
+    if (checkGitHub && githubTabs.length > 0) {
+        let index = 0;
+        const total = githubTabs.length;
+        const workers = Array.from({ length: Math.min(githubConcurrency, total) }, async () => {
+            while (true) {
+                const currentIndex = index;
+                if (currentIndex >= total) {
+                    return;
+                }
+                index += 1;
+                const tab = githubTabs[currentIndex];
+                const state = await detectGitHubState(tab.tabId, githubTimeoutMs);
+                githubChecked += 1;
+                if (state === "closed" || state === "merged") {
+                    githubMatched += 1;
+                    addReason(tab, {
+                        type: "closed_issue",
+                        detail: `GitHub state: ${state}`,
+                    });
+                }
+                if (progressEnabled) {
+                    deps.sendProgress(requestId, {
+                        phase: "github",
+                        processed: githubChecked,
+                        total,
+                        matched: githubMatched,
+                        tabId: tab.tabId,
+                        timeoutMs: githubTimeoutMs,
+                    });
+                }
+            }
+        });
+        await Promise.all(workers);
+    }
+    const candidates = Array.from(candidateMap.values()).map((entry) => {
+        const reasons = entry.reasons;
+        const severity = reasons.some((reason) => reason.type === "duplicate" || reason.type === "closed_issue")
+            ? "high"
+            : "medium";
+        return {
+            tabId: entry.tab.tabId,
+            windowId: entry.tab.windowId,
+            groupId: entry.tab.groupId,
+            url: entry.tab.url,
+            title: entry.tab.title,
+            lastFocusedAt: entry.tab.lastFocusedAt,
+            reasons,
+            severity,
+        };
+    });
+    return {
+        generatedAt: Date.now(),
+        staleDays,
+        totals: {
+            tabs: scopeTabs.length,
+            analyzed: selectedTabs.length,
+            candidates: candidates.length,
+        },
+        meta: {
+            durationMs: Date.now() - startedAt,
+            githubChecked,
+            githubTotal,
+            githubMatched,
+            githubTimeoutMs,
+        },
+        candidates,
+    };
+}
+async function inspectTabs(params, requestId, deps) {
+    const signalList = Array.isArray(params.signals) && params.signals.length > 0
+        ? params.signals.map(String)
+        : ["page-meta"];
+    const signalConcurrencyRaw = Number(params.signalConcurrency);
+    const signalConcurrency = Number.isFinite(signalConcurrencyRaw) && signalConcurrencyRaw > 0
+        ? Math.min(10, Math.floor(signalConcurrencyRaw))
+        : 4;
+    const signalTimeoutRaw = Number(params.signalTimeoutMs);
+    const signalTimeoutMs = Number.isFinite(signalTimeoutRaw) && signalTimeoutRaw > 0
+        ? Math.floor(signalTimeoutRaw)
+        : 4000;
+    const progressEnabled = params.progress === true;
+    // For settle mode with specific tab IDs, wait BEFORE taking snapshot
+    // This ensures the tab URL is available for isScriptableUrl() checks
+    const waitFor = typeof params.waitFor === "string" ? params.waitFor.trim().toLowerCase() : "";
+    if (waitFor === "settle" && Array.isArray(params.tabIds) && params.tabIds.length > 0) {
+        const waitTimeoutRaw = Number(params.waitTimeoutMs);
+        const waitTimeoutMs = Number.isFinite(waitTimeoutRaw) && waitTimeoutRaw > 0 ? Math.floor(waitTimeoutRaw) : signalTimeoutMs;
+        const tabIds = params.tabIds.map(Number).filter(Number.isFinite);
+        await Promise.all(tabIds.map((id) => waitForSettle(id, waitTimeoutMs)));
+    }
+    const snapshot = await deps.getTabSnapshot();
+    const selection = deps.selectTabsByScope(snapshot, params);
+    if (selection.error) {
+        throw selection.error;
+    }
+    const tabs = selection.tabs;
+    const startedAt = Date.now();
+    const selectorSpecs = [];
+    if (Array.isArray(params.selectorSpecs)) {
+        selectorSpecs.push(...params.selectorSpecs);
+    }
+    if (params.signalConfig && typeof params.signalConfig === "object") {
+        const config = params.signalConfig;
+        if (Array.isArray(config.selectors)) {
+            selectorSpecs.push(...config.selectors);
+        }
+        if (config.signals && typeof config.signals === "object") {
+            const signals = config.signals;
+            const selectorConfig = signals.selector;
+            if (selectorConfig && Array.isArray(selectorConfig.selectors)) {
+                selectorSpecs.push(...selectorConfig.selectors);
+            }
+        }
+    }
+    const normalizedSelectors = selectorSpecs
+        .filter((spec) => spec && typeof spec.selector === "string" && spec.selector.length > 0)
+        .map((spec) => ({
+        name: typeof spec.name === "string" ? spec.name : undefined,
+        selector: spec.selector,
+        attr: typeof spec.attr === "string" ? spec.attr : "text",
+        all: Boolean(spec.all),
+        text: typeof spec.text === "string" && spec.text.trim() ? spec.text.trim() : undefined,
+        textMode: typeof spec.textMode === "string" ? spec.textMode.trim().toLowerCase() : undefined,
+    }));
+    const selectorWarnings = normalizedSelectors
+        .filter((spec) => typeof spec.selector === "string" && spec.selector.includes(":contains("))
+        .map((spec) => ({
+        name: spec.name || spec.selector,
+        hint: "CSS :contains() is not supported; use selector text filters or a different selector.",
+    }));
+    const signalDefs = [];
+    for (const signalId of signalList) {
+        if (signalId === "github-state") {
+            signalDefs.push({
+                id: signalId,
+                match: (tab) => isGitHubIssueOrPr(tab.url) && isScriptableUrl(tab.url),
+                run: async (tabId) => {
+                    const state = await detectGitHubState(tabId, signalTimeoutMs);
+                    return state ? { state } : null;
+                },
+            });
+        }
+        else if (signalId === "page-meta") {
+            signalDefs.push({
+                id: signalId,
+                match: (tab) => isScriptableUrl(tab.url),
+                run: async (tabId) => extractPageMeta(tabId, signalTimeoutMs, exports.DESCRIPTION_MAX_LENGTH),
+            });
+        }
+        else if (signalId === "selector") {
+            signalDefs.push({
+                id: signalId,
+                match: (tab) => isScriptableUrl(tab.url),
+                run: async (tabId) => extractSelectorSignal(tabId, normalizedSelectors, signalTimeoutMs, exports.SELECTOR_VALUE_MAX_LENGTH),
+            });
+        }
+    }
+    const tasks = [];
+    for (const tab of tabs) {
+        for (const signal of signalDefs) {
+            if (signal.match(tab)) {
+                tasks.push({ tab, signal });
+            }
+        }
+    }
+    const totalTasks = tasks.length;
+    let completedTasks = 0;
+    const entryMap = new Map();
+    const workerCount = Math.min(signalConcurrency, totalTasks || 1);
+    let index = 0;
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const currentIndex = index;
+            if (currentIndex >= totalTasks) {
+                return;
+            }
+            index += 1;
+            const task = tasks[currentIndex];
+            const tabId = task.tab.tabId;
+            let result = null;
+            let error = null;
+            const started = Date.now();
+            try {
+                await waitForTabReady(tabId, params, signalTimeoutMs);
+                result = await task.signal.run(tabId);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : "signal_error";
+                error = message;
+            }
+            const durationMs = Date.now() - started;
+            const entry = entryMap.get(tabId) || { tab: task.tab, signals: {} };
+            entry.signals[task.signal.id] = {
+                ok: error === null,
+                durationMs,
+                data: result,
+                error,
+            };
+            entryMap.set(tabId, entry);
+            completedTasks += 1;
+            if (progressEnabled) {
+                deps.sendProgress(requestId, {
+                    phase: "inspect",
+                    processed: completedTasks,
+                    total: totalTasks,
+                    signalId: task.signal.id,
+                    tabId,
+                });
+            }
+        }
+    });
+    await Promise.all(workers);
+    const entries = Array.from(entryMap.values()).map((entry) => ({
+        tabId: entry.tab.tabId,
+        windowId: entry.tab.windowId,
+        groupId: entry.tab.groupId,
+        url: entry.tab.url,
+        title: entry.tab.title,
+        signals: entry.signals,
+    }));
+    return {
+        generatedAt: Date.now(),
+        totals: {
+            tabs: tabs.length,
+            signals: signalDefs.length,
+            tasks: totalTasks,
+        },
+        meta: {
+            durationMs: Date.now() - startedAt,
+            signalTimeoutMs,
+            selectorCount: normalizedSelectors.length,
+            selectorWarnings: selectorWarnings.length > 0 ? selectorWarnings : undefined,
+        },
+        entries,
+    };
+}

package/dist/extension/lib/move.js

@@ -0,0 +1,342 @@
+"use strict";
+// Tab/group movement — extracted from tabs.ts (pure structural refactor).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMoveTarget = resolveMoveTarget;
+exports.moveTab = moveTab;
+exports.moveGroup = moveGroup;
+const tabs = require("./tabs");
+const { normalizeTabIndex } = tabs;
+function resolveMoveTarget(snapshot, params, deps) {
+    const beforeTabId = Number(params.beforeTabId);
+    const afterTabId = Number(params.afterTabId);
+    const beforeGroupTitle = typeof params.beforeGroupTitle === "string" ? params.beforeGroupTitle.trim() : "";
+    const afterGroupTitle = typeof params.afterGroupTitle === "string" ? params.afterGroupTitle.trim() : "";
+    const targets = [
+        Number.isFinite(beforeTabId) ? "before-tab" : null,
+        Number.isFinite(afterTabId) ? "after-tab" : null,
+        beforeGroupTitle ? "before-group" : null,
+        afterGroupTitle ? "after-group" : null,
+    ].filter(Boolean);
+    if (targets.length === 0) {
+        return { error: { message: "Missing target position (--before/--after)" } };
+    }
+    if (targets.length > 1) {
+        return { error: { message: "Only one target position is allowed" } };
+    }
+    const windows = snapshot.windows;
+    const findTab = (tabId) => {
+        for (const win of windows) {
+            const tab = win.tabs.find((entry) => entry.tabId === tabId);
+            if (tab) {
+                return { tab, windowId: win.windowId };
+            }
+        }
+        return null;
+    };
+    if (targets[0] === "before-tab" || targets[0] === "after-tab") {
+        const tabId = targets[0] === "before-tab" ? beforeTabId : afterTabId;
+        if (!Number.isFinite(tabId)) {
+            return { error: { message: "Invalid tab target" } };
+        }
+        const match = findTab(tabId);
+        if (!match) {
+            return { error: { message: "Target tab not found" } };
+        }
+        const index = normalizeTabIndex(match.tab.index);
+        if (!Number.isFinite(index)) {
+            return { error: { message: "Target tab index unavailable" } };
+        }
+        return {
+            windowId: match.windowId,
+            index: targets[0] === "before-tab" ? index : index + 1,
+            anchor: { type: "tab", tabId },
+        };
+    }
+    const groupTitle = targets[0] === "before-group" ? beforeGroupTitle : afterGroupTitle;
+    const windowId = Number.isFinite(params.windowId) ? Number(params.windowId) : undefined;
+    const resolved = deps.resolveGroupByTitle(snapshot, groupTitle, windowId);
+    if (resolved.error) {
+        return resolved;
+    }
+    const match = resolved.match;
+    if (!match.tabs.length) {
+        return { error: { message: "Target group has no tabs" } };
+    }
+    const indices = match.tabs
+        .map((tab) => normalizeTabIndex(tab.index))
+        .filter((value) => value != null);
+    if (!indices.length) {
+        return { error: { message: "Target group indices unavailable" } };
+    }
+    const minIndex = Math.min(...indices);
+    const maxIndex = Math.max(...indices);
+    return {
+        windowId: match.windowId,
+        index: targets[0] === "before-group" ? minIndex : maxIndex + 1,
+        anchor: { type: "group", groupId: match.group.groupId, groupTitle },
+    };
+}
+async function moveTab(params, deps) {
+    const tabIds = Array.isArray(params.tabIds) ? params.tabIds.map(Number) : [];
+    const tabId = Number.isFinite(params.tabId)
+        ? Number(params.tabId)
+        : tabIds.length
+            ? Number(tabIds[0])
+            : null;
+    if (!tabId) {
+        throw new Error("Missing tabId");
+    }
+    const snapshot = await deps.getTabSnapshot();
+    const windows = snapshot.windows;
+    const sourceWindow = windows.find((win) => win.tabs.some((tab) => tab.tabId === tabId));
+    if (!sourceWindow) {
+        throw new Error("Source tab not found");
+    }
+    const sourceTab = sourceWindow.tabs.find((tab) => tab.tabId === tabId);
+    if (!sourceTab) {
+        throw new Error("Source tab not found");
+    }
+    const newWindow = params.newWindow === true;
+    const hasTarget = Number.isFinite(params.beforeTabId)
+        || Number.isFinite(params.afterTabId)
+        || (typeof params.beforeGroupTitle === "string" && params.beforeGroupTitle.trim())
+        || (typeof params.afterGroupTitle === "string" && params.afterGroupTitle.trim());
+    if (newWindow) {
+        if (hasTarget) {
+            throw new Error("Cannot combine --new-window with --before/--after");
+        }
+        const createdWindow = await chrome.windows.create({ tabId, focused: false });
+        const targetWindowId = createdWindow.id;
+        let targetIndex = 0;
+        const createdTab = createdWindow.tabs?.find((tab) => tab.id === tabId) || null;
+        if (createdTab && Number.isFinite(createdTab.index)) {
+            targetIndex = createdTab.index;
+        }
+        else {
+            try {
+                const updated = await chrome.tabs.get(tabId);
+                targetIndex = updated.index;
+            }
+            catch {
+                targetIndex = 0;
+            }
+        }
+        return {
+            tabId,
+            from: { windowId: sourceWindow.windowId, index: sourceTab.index },
+            to: { windowId: targetWindowId, index: targetIndex },
+            summary: { movedTabs: 1 },
+            undo: {
+                action: "move-tab",
+                tabId,
+                from: {
+                    windowId: sourceWindow.windowId,
+                    index: sourceTab.index,
+                    groupId: sourceTab.groupId,
+                    groupTitle: sourceTab.groupTitle,
+                    groupColor: sourceTab.groupColor,
+                    groupCollapsed: sourceTab.groupCollapsed ?? null,
+                },
+                to: {
+                    windowId: targetWindowId,
+                    index: targetIndex,
+                },
+            },
+            txid: params.txid || null,
+        };
+    }
+    let normalizedParams = params;
+    if (params.windowId != null) {
+        const resolvedWindowId = deps.resolveWindowIdFromParams(snapshot, params.windowId);
+        normalizedParams = { ...params, windowId: resolvedWindowId ?? undefined };
+    }
+    const target = resolveMoveTarget(snapshot, normalizedParams, deps);
+    if (target.error) {
+        throw target.error;
+    }
+    const targetWindowId = target.windowId;
+    let targetIndex = target.index;
+    const sourceIndex = normalizeTabIndex(sourceTab.index);
+    if (Number.isFinite(sourceIndex) && sourceWindow.windowId === targetWindowId && sourceIndex < targetIndex) {
+        targetIndex -= 1;
+    }
+    const moved = await chrome.tabs.move(tabId, { windowId: targetWindowId, index: targetIndex });
+    return {
+        tabId,
+        from: { windowId: sourceWindow.windowId, index: sourceTab.index },
+        to: { windowId: targetWindowId, index: moved.index },
+        summary: { movedTabs: 1 },
+        undo: {
+            action: "move-tab",
+            tabId,
+            from: {
+                windowId: sourceWindow.windowId,
+                index: sourceTab.index,
+                groupId: sourceTab.groupId,
+                groupTitle: sourceTab.groupTitle,
+                groupColor: sourceTab.groupColor,
+                groupCollapsed: sourceTab.groupCollapsed ?? null,
+            },
+            to: {
+                windowId: targetWindowId,
+                index: moved.index,
+            },
+        },
+        txid: params.txid || null,
+    };
+}
+async function moveGroup(params, deps) {
+    const groupId = Number.isFinite(params.groupId) ? Number(params.groupId) : null;
+    const groupTitle = typeof params.groupTitle === "string" ? params.groupTitle.trim() : "";
+    if (!groupId && !groupTitle) {
+        throw new Error("Missing group identifier");
+    }
+    const snapshot = await deps.getTabSnapshot();
+    const windowIdParam = params.windowId != null ? deps.resolveWindowIdFromParams(snapshot, params.windowId) ?? undefined : undefined;
+    const resolvedGroup = groupId != null
+        ? deps.resolveGroupById(snapshot, groupId)
+        : deps.resolveGroupByTitle(snapshot, groupTitle, windowIdParam);
+    if (resolvedGroup.error) {
+        throw resolvedGroup.error;
+    }
+    const source = resolvedGroup.match;
+    if (!source.tabs.length) {
+        throw new Error("Group has no tabs to move");
+    }
+    const newWindow = params.newWindow === true;
+    const hasTarget = Number.isFinite(params.beforeTabId)
+        || Number.isFinite(params.afterTabId)
+        || (typeof params.beforeGroupTitle === "string" && params.beforeGroupTitle.trim())
+        || (typeof params.afterGroupTitle === "string" && params.afterGroupTitle.trim());
+    if (newWindow) {
+        if (hasTarget) {
+            throw new Error("Cannot combine --new-window with --before/--after");
+        }
+        const tabIds = source.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+        const [firstTabId, ...restTabIds] = tabIds;
+        if (!firstTabId) {
+            throw new Error("Group has no tabs to move");
+        }
+        const createdWindow = await chrome.windows.create({ tabId: firstTabId, focused: false });
+        const targetWindowId = createdWindow.id;
+        if (restTabIds.length > 0) {
+            await chrome.tabs.move(restTabIds, { windowId: targetWindowId, index: -1 });
+        }
+        let newGroupId = null;
+        try {
+            newGroupId = await chrome.tabs.group({ tabIds, createProperties: { windowId: targetWindowId } });
+            await chrome.tabGroups.update(newGroupId, {
+                title: source.group.title || "",
+                color: source.group.color || "grey",
+                collapsed: source.group.collapsed || false,
+            });
+        }
+        catch (error) {
+            deps.log("Failed to regroup tabs", error);
+        }
+        const undoTabs = source.tabs
+            .map((tab) => ({
+            tabId: tab.tabId,
+            windowId: tab.windowId,
+            index: tab.index,
+            groupId: tab.groupId,
+            groupTitle: tab.groupTitle,
+            groupColor: tab.groupColor,
+            groupCollapsed: source.group.collapsed ?? null,
+        }))
+            .filter((tab) => typeof tab.tabId === "number");
+        return {
+            groupId: source.group.groupId,
+            windowId: source.windowId,
+            movedToWindowId: targetWindowId,
+            newGroupId,
+            summary: { movedTabs: tabIds.length },
+            undo: {
+                action: "move-group",
+                groupId: source.group.groupId,
+                windowId: source.windowId,
+                movedToWindowId: targetWindowId,
+                groupTitle: source.group.title ?? null,
+                groupColor: source.group.color ?? null,
+                groupCollapsed: source.group.collapsed ?? null,
+                tabs: undoTabs,
+            },
+            txid: params.txid || null,
+        };
+    }
+    const target = resolveMoveTarget(snapshot, params, deps);
+    if (target.error) {
+        throw target.error;
+    }
+    if (target.anchor?.type === "tab") {
+        const anchorTabId = target.anchor.tabId;
+        if (source.tabs.some((tab) => tab.tabId === anchorTabId)) {
+            throw new Error("Target tab is within the source group");
+        }
+    }
+    if (target.anchor?.type === "group") {
+        const anchorGroupId = target.anchor.groupId;
+        if (anchorGroupId === source.group.groupId && source.windowId === target.windowId) {
+            throw new Error("Target group matches source group");
+        }
+    }
+    const tabIds = source.tabs.map((tab) => tab.tabId).filter((id) => typeof id === "number");
+    const indices = source.tabs
+        .map((tab) => normalizeTabIndex(tab.index))
+        .filter((value) => value != null);
+    const minIndex = Math.min(...indices);
+    const maxIndex = Math.max(...indices);
+    const targetWindowId = target.windowId;
+    let targetIndex = target.index;
+    if (source.windowId === targetWindowId && targetIndex > maxIndex) {
+        targetIndex -= tabIds.length;
+    }
+    const moved = await chrome.tabs.move(tabIds, { windowId: targetWindowId, index: targetIndex });
+    const movedList = Array.isArray(moved) ? moved : [moved];
+    let newGroupId = null;
+    if (targetWindowId !== source.windowId) {
+        try {
+            const movedIds = movedList.map((tab) => tab.id).filter((id) => typeof id === "number");
+            if (movedIds.length > 0) {
+                newGroupId = await chrome.tabs.group({ tabIds: movedIds, createProperties: { windowId: targetWindowId } });
+                await chrome.tabGroups.update(newGroupId, {
+                    title: source.group.title || "",
+                    color: source.group.color || "grey",
+                    collapsed: source.group.collapsed || false,
+                });
+            }
+        }
+        catch (error) {
+            deps.log("Failed to regroup tabs", error);
+        }
+    }
+    const undoTabs = source.tabs
+        .map((tab) => ({
+        tabId: tab.tabId,
+        windowId: tab.windowId,
+        index: tab.index,
+        groupId: tab.groupId,
+        groupTitle: tab.groupTitle,
+        groupColor: tab.groupColor,
+        groupCollapsed: source.group.collapsed ?? null,
+    }))
+        .filter((tab) => typeof tab.tabId === "number");
+    return {
+        groupId: source.group.groupId,
+        windowId: source.windowId,
+        movedToWindowId: targetWindowId,
+        newGroupId,
+        summary: { movedTabs: tabIds.length },
+        undo: {
+            action: "move-group",
+            groupId: source.group.groupId,
+            windowId: source.windowId,
+            movedToWindowId: targetWindowId,
+            groupTitle: source.group.title ?? null,
+            groupColor: source.group.color ?? null,
+            groupCollapsed: source.group.collapsed ?? null,
+            tabs: undoTabs,
+        },
+        txid: params.txid || null,
+    };
+}