tabctl 0.1.4 → 0.2.1

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

@@ -0,0 +1,439 @@
+"use strict";
+// Undo transaction handlers — extracted from background.ts (pure structural refactor).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undoGroupUpdate = undoGroupUpdate;
+exports.undoGroupUngroup = undoGroupUngroup;
+exports.undoGroupAssign = undoGroupAssign;
+exports.undoMoveTab = undoMoveTab;
+exports.undoMoveGroup = undoMoveGroup;
+exports.undoMergeWindow = undoMergeWindow;
+exports.undoArchive = undoArchive;
+exports.undoClose = undoClose;
+exports.undoTransaction = undoTransaction;
+async function ensureWindow(windowId) {
+    if (windowId) {
+        try {
+            const existing = await chrome.windows.get(windowId);
+            if (existing) {
+                return windowId;
+            }
+        }
+        catch {
+            // fall through to create
+        }
+    }
+    const created = await chrome.windows.create({ focused: false });
+    return created.id;
+}
+async function restoreTabsFromUndo(entries, deps) {
+    const skipped = [];
+    const restored = [];
+    const windowMap = new Map();
+    for (const entry of entries) {
+        const tabId = Number(entry.tabId);
+        if (!Number.isFinite(tabId)) {
+            skipped.push({ tabId: entry.tabId, reason: "missing_tab" });
+            continue;
+        }
+        const sourceWindowId = Number(entry.windowId);
+        if (!Number.isFinite(sourceWindowId)) {
+            skipped.push({ tabId, reason: "missing_window" });
+            continue;
+        }
+        let targetWindowId = windowMap.get(sourceWindowId);
+        if (!targetWindowId) {
+            targetWindowId = await ensureWindow(sourceWindowId);
+            windowMap.set(sourceWindowId, targetWindowId);
+        }
+        try {
+            await chrome.tabs.move(tabId, { windowId: targetWindowId, index: -1 });
+            restored.push({ tabId, entry, targetWindowId });
+        }
+        catch {
+            skipped.push({ tabId, reason: "move_failed" });
+        }
+    }
+    const groupsByWindow = new Map();
+    for (const item of restored) {
+        const entry = item.entry;
+        const rawGroupId = typeof entry.groupId === "number" ? entry.groupId : null;
+        const groupId = rawGroupId != null && rawGroupId !== -1 ? rawGroupId : null;
+        const groupTitle = typeof entry.groupTitle === "string" ? entry.groupTitle : null;
+        if (!groupId && !groupTitle) {
+            continue;
+        }
+        const groupKey = groupId != null ? `id:${groupId}` : `title:${groupTitle}`;
+        const key = `${item.targetWindowId}:${groupKey}`;
+        if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, {
+                windowId: item.targetWindowId,
+                groupId,
+                groupTitle,
+                groupColor: typeof entry.groupColor === "string" ? entry.groupColor : null,
+                groupCollapsed: typeof entry.groupCollapsed === "boolean" ? entry.groupCollapsed : null,
+                tabIds: [],
+            });
+        }
+        groupsByWindow.get(key)?.tabIds.push(item.tabId);
+    }
+    for (const group of groupsByWindow.values()) {
+        if (group.tabIds.length === 0) {
+            continue;
+        }
+        let targetGroupId = null;
+        if (group.groupId != null) {
+            try {
+                targetGroupId = await chrome.tabs.group({ groupId: group.groupId, tabIds: group.tabIds });
+            }
+            catch {
+                targetGroupId = null;
+            }
+        }
+        if (targetGroupId == null) {
+            try {
+                targetGroupId = await chrome.tabs.group({
+                    tabIds: group.tabIds,
+                    createProperties: { windowId: group.windowId },
+                });
+            }
+            catch (error) {
+                deps.log("Failed to regroup tabs", error);
+                continue;
+            }
+        }
+        const update = {};
+        if (typeof group.groupTitle === "string") {
+            update.title = group.groupTitle;
+        }
+        if (typeof group.groupColor === "string" && group.groupColor) {
+            update.color = group.groupColor;
+        }
+        if (typeof group.groupCollapsed === "boolean") {
+            update.collapsed = group.groupCollapsed;
+        }
+        if (Object.keys(update).length > 0) {
+            try {
+                await chrome.tabGroups.update(targetGroupId, update);
+            }
+            catch (error) {
+                deps.log("Failed to update restored group", error);
+            }
+        }
+    }
+    const orderByWindow = new Map();
+    for (const item of restored) {
+        const index = Number(item.entry.index);
+        if (!Number.isFinite(index)) {
+            continue;
+        }
+        if (!orderByWindow.has(item.targetWindowId)) {
+            orderByWindow.set(item.targetWindowId, []);
+        }
+        orderByWindow.get(item.targetWindowId)?.push({ tabId: item.tabId, index });
+    }
+    for (const [targetWindowId, items] of orderByWindow.entries()) {
+        const ordered = [...items].sort((a, b) => a.index - b.index);
+        for (const item of ordered) {
+            try {
+                await chrome.tabs.move(item.tabId, { windowId: targetWindowId, index: item.index });
+            }
+            catch {
+                // ignore ordering failures
+            }
+        }
+    }
+    return {
+        summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length,
+        },
+        skipped,
+    };
+}
+async function undoGroupUpdate(undo) {
+    const groupId = Number(undo.groupId);
+    if (!Number.isFinite(groupId)) {
+        return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId: undo.groupId, reason: "missing_group" }],
+        };
+    }
+    const previous = undo.previous || {};
+    const update = {};
+    if (typeof previous.title === "string") {
+        update.title = previous.title;
+    }
+    if (typeof previous.color === "string" && previous.color) {
+        update.color = previous.color;
+    }
+    if (typeof previous.collapsed === "boolean") {
+        update.collapsed = previous.collapsed;
+    }
+    if (!Object.keys(update).length) {
+        return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId, reason: "missing_values" }],
+        };
+    }
+    try {
+        await chrome.tabGroups.update(groupId, update);
+        return {
+            summary: { restoredGroups: 1, skippedGroups: 0 },
+            skipped: [],
+        };
+    }
+    catch {
+        return {
+            summary: { restoredGroups: 0, skippedGroups: 1 },
+            skipped: [{ groupId, reason: "update_failed" }],
+        };
+    }
+}
+async function undoGroupUngroup(undo, deps) {
+    const tabs = undo.tabs || [];
+    return await restoreTabsFromUndo(tabs, deps);
+}
+async function undoGroupAssign(undo, deps) {
+    const tabs = undo.tabs || [];
+    return await restoreTabsFromUndo(tabs, deps);
+}
+async function undoMoveTab(undo, deps) {
+    const from = undo.from || {};
+    const entry = {
+        tabId: undo.tabId,
+        windowId: from.windowId,
+        index: from.index,
+        groupId: from.groupId,
+        groupTitle: from.groupTitle,
+        groupColor: from.groupColor,
+        groupCollapsed: from.groupCollapsed,
+    };
+    return await restoreTabsFromUndo([entry], deps);
+}
+async function undoMoveGroup(undo, deps) {
+    const tabs = undo.tabs || [];
+    return await restoreTabsFromUndo(tabs, deps);
+}
+async function undoMergeWindow(undo, deps) {
+    const tabs = undo.tabs || [];
+    return await restoreTabsFromUndo(tabs, deps);
+}
+async function undoArchive(undo, deps) {
+    const tabs = undo.tabs || [];
+    const restored = [];
+    const skipped = [];
+    const windowMap = new Map();
+    for (const entry of tabs) {
+        if (!entry.tabId) {
+            skipped.push({ tabId: entry.tabId, reason: "missing_tab" });
+            continue;
+        }
+        let targetWindowId = windowMap.get(entry.from.windowId);
+        if (!targetWindowId) {
+            targetWindowId = await ensureWindow(entry.from.windowId);
+            windowMap.set(entry.from.windowId, targetWindowId);
+        }
+        try {
+            await chrome.tabs.move(entry.tabId, { windowId: targetWindowId, index: -1 });
+            restored.push({ tabId: entry.tabId, targetWindowId });
+        }
+        catch {
+            skipped.push({ tabId: entry.tabId, reason: "move_failed" });
+        }
+    }
+    const restoredSet = new Set(restored.map((item) => item.tabId));
+    const groupsByWindow = new Map();
+    for (const entry of tabs) {
+        if (!restoredSet.has(entry.tabId)) {
+            continue;
+        }
+        const targetWindowId = windowMap.get(entry.from.windowId) || entry.from.windowId;
+        const hasGroupId = entry.from.groupId != null && entry.from.groupId !== -1;
+        const hasGroupTitle = entry.from.groupTitle != null;
+        if (!hasGroupId && !hasGroupTitle) {
+            continue;
+        }
+        const groupKey = hasGroupId ? entry.from.groupId : entry.from.groupTitle;
+        const key = `${targetWindowId}:${groupKey}`;
+        if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, []);
+        }
+        groupsByWindow.get(key)?.push(entry);
+    }
+    for (const [key, groupTabs] of groupsByWindow.entries()) {
+        const [windowIdPart] = key.split(":");
+        const targetWindowId = Number(windowIdPart);
+        const tabIds = groupTabs.map((entry) => entry.tabId).filter(Boolean);
+        if (!tabIds.length) {
+            continue;
+        }
+        try {
+            const groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId: targetWindowId } });
+            await chrome.tabGroups.update(groupId, {
+                title: groupTabs[0].from.groupTitle || "",
+                color: groupTabs[0].from.groupColor || "grey",
+                collapsed: groupTabs[0].from.groupCollapsed || false,
+            });
+        }
+        catch (error) {
+            deps.log("Failed to recreate group", error);
+        }
+    }
+    for (const [originalWindowId, targetWindowId] of windowMap.entries()) {
+        const windowTabs = tabs
+            .filter((entry) => entry.from.windowId === originalWindowId && restoredSet.has(entry.tabId))
+            .sort((a, b) => a.from.index - b.from.index);
+        for (const entry of windowTabs) {
+            if (!entry.tabId) {
+                continue;
+            }
+            try {
+                await chrome.tabs.move(entry.tabId, { windowId: targetWindowId, index: entry.from.index });
+            }
+            catch {
+                // ignore ordering failures
+            }
+        }
+        const activeTab = windowTabs.find((entry) => entry.active);
+        if (activeTab && activeTab.tabId) {
+            try {
+                await chrome.tabs.update(activeTab.tabId, { active: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return {
+        summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length,
+        },
+        skipped,
+    };
+}
+async function undoClose(undo, deps) {
+    const tabs = undo.tabs || [];
+    const restored = [];
+    const skipped = [];
+    const windowMap = new Map();
+    for (const entry of tabs) {
+        if (!entry.url) {
+            skipped.push({ url: entry.url, reason: "missing_url" });
+            continue;
+        }
+        let targetWindowId = windowMap.get(entry.from.windowId);
+        if (!targetWindowId) {
+            targetWindowId = await ensureWindow(entry.from.windowId);
+            windowMap.set(entry.from.windowId, targetWindowId);
+        }
+        try {
+            const created = await chrome.tabs.create({
+                windowId: targetWindowId,
+                url: entry.url,
+                active: false,
+                pinned: entry.pinned,
+            });
+            restored.push({ tabId: created.id, entry });
+        }
+        catch {
+            skipped.push({ url: entry.url, reason: "create_failed" });
+        }
+    }
+    const groupsByWindow = new Map();
+    for (const item of restored) {
+        const entry = item.entry;
+        const targetWindowId = windowMap.get(entry.from.windowId) || entry.from.windowId;
+        const hasGroupId = entry.from.groupId != null && entry.from.groupId !== -1;
+        const hasGroupTitle = entry.from.groupTitle != null;
+        if (!hasGroupId && !hasGroupTitle) {
+            continue;
+        }
+        const groupKey = hasGroupId ? entry.from.groupId : entry.from.groupTitle;
+        const key = `${targetWindowId}:${groupKey}`;
+        if (!groupsByWindow.has(key)) {
+            groupsByWindow.set(key, []);
+        }
+        groupsByWindow.get(key)?.push({ tabId: item.tabId, entry });
+    }
+    for (const [key, groupTabs] of groupsByWindow.entries()) {
+        const [windowIdPart] = key.split(":");
+        const targetWindowId = Number(windowIdPart);
+        const tabIds = groupTabs.map((item) => item.tabId).filter(Boolean);
+        if (!tabIds.length) {
+            continue;
+        }
+        try {
+            const groupId = await chrome.tabs.group({ tabIds, createProperties: { windowId: targetWindowId } });
+            await chrome.tabGroups.update(groupId, {
+                title: groupTabs[0].entry.from.groupTitle || "",
+                color: groupTabs[0].entry.from.groupColor || "grey",
+                collapsed: groupTabs[0].entry.from.groupCollapsed || false,
+            });
+        }
+        catch (error) {
+            deps.log("Failed to recreate group", error);
+        }
+    }
+    for (const [originalWindowId, targetWindowId] of windowMap.entries()) {
+        const windowTabs = restored
+            .map((item) => ({ tabId: item.tabId, entry: item.entry }))
+            .filter((item) => item.entry.from.windowId === originalWindowId)
+            .sort((a, b) => a.entry.from.index - b.entry.from.index);
+        for (const item of windowTabs) {
+            try {
+                await chrome.tabs.move(item.tabId, { windowId: targetWindowId, index: item.entry.from.index });
+            }
+            catch {
+                // ignore ordering failures
+            }
+        }
+        const activeTab = windowTabs.find((item) => item.entry.active);
+        if (activeTab) {
+            try {
+                await chrome.tabs.update(activeTab.tabId, { active: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return {
+        summary: {
+            restoredTabs: restored.length,
+            skippedTabs: skipped.length,
+        },
+        skipped,
+    };
+}
+async function undoTransaction(params, deps) {
+    if (!params.record || !params.record.undo) {
+        throw new Error("Undo record missing");
+    }
+    const undo = params.record.undo;
+    if (undo.action === "archive") {
+        return await undoArchive(undo, deps);
+    }
+    if (undo.action === "close") {
+        return await undoClose(undo, deps);
+    }
+    if (undo.action === "group-update") {
+        return await undoGroupUpdate(undo);
+    }
+    if (undo.action === "group-ungroup") {
+        return await undoGroupUngroup(undo, deps);
+    }
+    if (undo.action === "group-assign") {
+        return await undoGroupAssign(undo, deps);
+    }
+    if (undo.action === "move-tab") {
+        return await undoMoveTab(undo, deps);
+    }
+    if (undo.action === "move-group") {
+        return await undoMoveGroup(undo, deps);
+    }
+    if (undo.action === "merge-window") {
+        return await undoMergeWindow(undo, deps);
+    }
+    throw new Error(`Unknown undo action: ${undo.action}`);
+}

package/{extension → dist/extension}/manifest.json

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

package/dist/host/host.js

@@ -0,0 +1,124 @@
+#!/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 net_1 = __importDefault(require("net"));
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = require("../shared/config");
+const handlers_1 = require("./lib/handlers");
+let config;
+try {
+    config = (0, config_1.resolveConfig)();
+}
+catch (err) {
+    process.stderr.write(`[tabctl-host] Fatal: ${err.message}\n`);
+    process.exit(1);
+}
+const SOCKET_DIR = config.dataDir;
+const SOCKET_PATH = config.socketPath;
+const pending = new Map();
+const analyses = new Map();
+function log(...args) {
+    process.stderr.write(`[tabctl-host] ${args.join(" ")}\n`);
+}
+function ensureDir() {
+    fs_1.default.mkdirSync(SOCKET_DIR, { recursive: true, mode: 0o700 });
+}
+function createId(prefix) {
+    return `${prefix}-${Date.now()}-${crypto_1.default.randomBytes(4).toString("hex")}`;
+}
+function sendNative(message) {
+    const json = JSON.stringify(message);
+    const length = Buffer.byteLength(json);
+    const buffer = Buffer.alloc(4 + length);
+    buffer.writeUInt32LE(length, 0);
+    buffer.write(json, 4);
+    process.stdout.write(buffer);
+}
+const deps = {
+    pending,
+    analyses,
+    undoLog: config.undoLog,
+    createId,
+    sendNative,
+    log,
+};
+function handleNativeMessage(payload) {
+    (0, handlers_1.handleNativeMessage)(deps, payload);
+}
+function handleCliRequest(socket, request) {
+    (0, handlers_1.handleCliRequest)(deps, socket, request);
+}
+let nativeBuffer = Buffer.alloc(0);
+process.stdin.on("data", (chunk) => {
+    nativeBuffer = Buffer.concat([nativeBuffer, chunk]);
+    while (nativeBuffer.length >= 4) {
+        const length = nativeBuffer.readUInt32LE(0);
+        if (nativeBuffer.length < 4 + length) {
+            return;
+        }
+        const payload = nativeBuffer.slice(4, 4 + length).toString("utf8");
+        nativeBuffer = nativeBuffer.slice(4 + length);
+        handleNativeMessage(payload);
+    }
+});
+process.stdin.on("end", () => {
+    log("Extension disconnected, exiting");
+    cleanupAndExit(0);
+});
+function startSocketServer() {
+    ensureDir();
+    if (fs_1.default.existsSync(SOCKET_PATH)) {
+        fs_1.default.unlinkSync(SOCKET_PATH);
+    }
+    const server = net_1.default.createServer((socket) => {
+        socket.setEncoding("utf8");
+        let buffer = "";
+        socket.on("data", (data) => {
+            buffer += data;
+            let index;
+            while ((index = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, index).trim();
+                buffer = buffer.slice(index + 1);
+                if (!line) {
+                    continue;
+                }
+                let request;
+                try {
+                    request = JSON.parse(line);
+                }
+                catch {
+                    (0, handlers_1.respond)(socket, { ok: false, error: { message: "Invalid JSON" } });
+                    continue;
+                }
+                handleCliRequest(socket, request);
+            }
+        });
+        socket.on("error", (error) => {
+            log("CLI socket error", error.message);
+        });
+    });
+    server.listen(SOCKET_PATH, () => {
+        fs_1.default.chmodSync(SOCKET_PATH, 0o600);
+        log(`Listening on ${SOCKET_PATH}`);
+    });
+    return server;
+}
+function cleanupAndExit(code) {
+    try {
+        if (fs_1.default.existsSync(SOCKET_PATH)) {
+            fs_1.default.unlinkSync(SOCKET_PATH);
+        }
+    }
+    catch {
+        // ignore
+    }
+    process.exit(code);
+}
+const server = startSocketServer();
+process.on("SIGINT", () => cleanupAndExit(0));
+process.on("SIGTERM", () => cleanupAndExit(0));
+server.on("close", () => cleanupAndExit(0));