tabctl 0.5.3 → 0.6.0-alpha.10

package/dist/extension/lib/inspect.js

@@ -1,252 +0,0 @@
-"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, 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 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();
-    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 candidates = Array.from(candidateMap.values()).map((entry) => {
-        const reasons = entry.reasons;
-        const severity = reasons.some((reason) => reason.type === "duplicate")
-            ? "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,
-        },
-        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 === "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

@@ -1,342 +0,0 @@
-"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,
-    };
-}