tabctl 0.1.0

package/extension/manifest.json

@@ -0,0 +1,23 @@
+{
+  "manifest_version": 3,
+  "name": "Tab Control",
+  "version": "0.1.0",
+  "description": "Archive and manage browser tabs with CLI support",
+  "permissions": [
+    "tabs",
+    "tabGroups",
+    "scripting",
+    "storage",
+    "downloads",
+    "nativeMessaging",
+    "sessions",
+    "alarms"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "version_name": "0.1.0-dev.0022fa28.dirty"
+}

package/extension/manifest.template.json

@@ -0,0 +1,22 @@
+{
+  "manifest_version": 3,
+  "name": "Tab Control",
+  "version": "0.1.0",
+  "description": "Archive and manage browser tabs with CLI support",
+  "permissions": [
+    "tabs",
+    "tabGroups",
+    "scripting",
+    "storage",
+    "downloads",
+    "nativeMessaging",
+    "sessions",
+    "alarms"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  }
+}

package/host/host.js

@@ -0,0 +1,428 @@
+#!/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 version_1 = require("../shared/version");
+const config_1 = require("../shared/config");
+const undo_1 = require("./lib/undo");
+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 UNDO_LOG = config.undoLog;
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+const HISTORY_LIMIT_DEFAULT = 20;
+const RETENTION_DAYS = 30;
+const pending = new Map();
+const analyses = new Map();
+const UNDO_ACTIONS = new Set([
+    "archive",
+    "close",
+    "group-update",
+    "group-ungroup",
+    "group-assign",
+    "move-tab",
+    "move-group",
+    "merge-window",
+]);
+const LOCAL_ACTIONS = new Set(["history", "undo", "version"]);
+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);
+}
+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 handleNativeMessage(payload) {
+    let message;
+    try {
+        message = JSON.parse(payload);
+    }
+    catch (error) {
+        const err = error;
+        log("Failed to parse native message", err.message);
+        return;
+    }
+    const messageId = message.id;
+    if (!messageId) {
+        return;
+    }
+    const pendingRequest = pending.get(messageId);
+    if (!pendingRequest) {
+        return;
+    }
+    if (message.progress) {
+        refreshTimeout(pendingRequest, messageId);
+        respond(pendingRequest.socket, {
+            ok: true,
+            action: pendingRequest.action,
+            requestId: messageId,
+            progress: true,
+            component: "host",
+            version: version_1.VERSION,
+            data: message.data || {},
+        });
+        return;
+    }
+    const messageData = message.data || {};
+    const extensionVersion = typeof messageData.version === "string" ? messageData.version : null;
+    const extensionComponent = typeof messageData.component === "string" ? messageData.component : null;
+    if (extensionVersion && extensionVersion !== version_1.VERSION) {
+        log(`Version mismatch: host ${version_1.VERSION}, extension ${extensionVersion}`);
+    }
+    clearTimeout(pendingRequest.timeout);
+    pending.delete(messageId);
+    if (!message.ok) {
+        respond(pendingRequest.socket, {
+            ok: false,
+            action: pendingRequest.action,
+            requestId: messageId,
+            component: "host",
+            version: version_1.VERSION,
+            error: message.error || { message: "Unknown error" },
+        });
+        return;
+    }
+    if (pendingRequest.action === "analyze") {
+        const analysisId = createId("analysis");
+        analyses.set(analysisId, {
+            createdAt: Date.now(),
+            data: messageData,
+        });
+        respond(pendingRequest.socket, {
+            ok: true,
+            action: "analyze",
+            requestId: messageId,
+            component: "host",
+            version: version_1.VERSION,
+            data: {
+                ...messageData,
+                extensionVersion,
+                extensionComponent,
+                hostBaseVersion: version_1.BASE_VERSION,
+                hostGitSha: version_1.GIT_SHA,
+                hostDirty: version_1.DIRTY,
+                analysisId,
+            },
+        });
+        return;
+    }
+    if (UNDO_ACTIONS.has(pendingRequest.action)) {
+        const record = {
+            txid: pendingRequest.txid,
+            createdAt: Date.now(),
+            action: pendingRequest.action,
+            summary: messageData.summary || {},
+            undo: messageData.undo || null,
+        };
+        if (record.undo) {
+            (0, undo_1.appendUndoRecord)(UNDO_LOG, record);
+        }
+        respond(pendingRequest.socket, {
+            ok: true,
+            action: pendingRequest.action,
+            requestId: messageId,
+            component: "host",
+            version: version_1.VERSION,
+            data: {
+                ...messageData,
+                extensionVersion,
+                extensionComponent,
+                hostBaseVersion: version_1.BASE_VERSION,
+                hostGitSha: version_1.GIT_SHA,
+                hostDirty: version_1.DIRTY,
+                txid: pendingRequest.txid,
+            },
+        });
+        return;
+    }
+    respond(pendingRequest.socket, {
+        ok: true,
+        action: pendingRequest.action,
+        requestId: messageId,
+        component: "host",
+        version: version_1.VERSION,
+        data: {
+            ...messageData,
+            extensionVersion,
+            extensionComponent,
+            hostBaseVersion: version_1.BASE_VERSION,
+            hostGitSha: version_1.GIT_SHA,
+            hostDirty: version_1.DIRTY,
+        },
+    });
+}
+function respond(socket, payload) {
+    const serialized = JSON.stringify(payload);
+    if (Buffer.byteLength(serialized, "utf8") > MAX_RESPONSE_BYTES) {
+        socket.write(`${JSON.stringify({
+            ok: false,
+            action: payload.action,
+            requestId: payload.requestId,
+            component: "host",
+            version: version_1.VERSION,
+            error: { message: "Response too large", hint: "Reduce scope or use --out to write files." },
+        })}\n`);
+        return;
+    }
+    socket.write(`${serialized}\n`);
+}
+function refreshTimeout(pendingRequest, requestId) {
+    clearTimeout(pendingRequest.timeout);
+    pendingRequest.timeout = setTimeout(() => {
+        pending.delete(requestId);
+        respond(pendingRequest.socket, {
+            ok: false,
+            action: pendingRequest.action,
+            requestId,
+            component: "host",
+            version: version_1.VERSION,
+            error: { message: "Request timed out" },
+        });
+    }, REQUEST_TIMEOUT_MS);
+}
+function forwardToExtension(socket, request, overrides = {}) {
+    const requestId = request.id || createId("req");
+    const txid = overrides.txid || null;
+    const params = { ...(request.params || {}) };
+    if (txid) {
+        params.txid = txid;
+    }
+    if (!LOCAL_ACTIONS.has(request.action)) {
+        params.client = {
+            component: "host",
+            version: version_1.VERSION,
+        };
+    }
+    pending.set(requestId, {
+        socket,
+        action: request.action,
+        txid,
+        timeout: setTimeout(() => {
+            pending.delete(requestId);
+            respond(socket, {
+                ok: false,
+                action: request.action,
+                requestId,
+                component: "host",
+                version: version_1.VERSION,
+                error: { message: "Request timed out" },
+            });
+        }, REQUEST_TIMEOUT_MS),
+    });
+    sendNative({ id: requestId, action: request.action, params });
+}
+function handleCliRequest(socket, request) {
+    if (!request || typeof request !== "object") {
+        respond(socket, { ok: false, error: { message: "Invalid request" } });
+        return;
+    }
+    const action = request.action;
+    if (!action) {
+        respond(socket, { ok: false, error: { message: "Missing action" } });
+        return;
+    }
+    if (action === "history") {
+        const limit = Number.isFinite(request.params?.limit)
+            ? Number(request.params?.limit)
+            : HISTORY_LIMIT_DEFAULT;
+        const records = (0, undo_1.readUndoRecords)(UNDO_LOG);
+        const filtered = (0, undo_1.filterByRetention)(records, RETENTION_DAYS);
+        respond(socket, {
+            ok: true,
+            action,
+            requestId: request.id || null,
+            component: "host",
+            version: version_1.VERSION,
+            data: filtered.slice(-limit),
+        });
+        return;
+    }
+    if (action === "version") {
+        respond(socket, {
+            ok: true,
+            action,
+            requestId: request.id || null,
+            component: "host",
+            version: version_1.VERSION,
+            data: {
+                version: version_1.VERSION,
+                baseVersion: version_1.BASE_VERSION,
+                gitSha: version_1.GIT_SHA,
+                dirty: version_1.DIRTY,
+                component: "host",
+            },
+        });
+        return;
+    }
+    if (action === "undo") {
+        const txid = request.params?.txid;
+        const latest = request.params?.latest === true;
+        if (!txid && !latest) {
+            respond(socket, {
+                ok: false,
+                action,
+                component: "host",
+                version: version_1.VERSION,
+                error: {
+                    message: "Missing txid",
+                    hint: "Use tabctl history --json to find a txid, or run tabctl undo --latest",
+                },
+            });
+            return;
+        }
+        const record = txid
+            ? (0, undo_1.findUndoRecord)(UNDO_LOG, txid, RETENTION_DAYS)
+            : (0, undo_1.findLatestUndoRecord)(UNDO_LOG, RETENTION_DAYS);
+        if (!record) {
+            respond(socket, { ok: false, action, component: "host", version: version_1.VERSION, error: { message: "Undo record not found" } });
+            return;
+        }
+        forwardToExtension(socket, {
+            id: request.id,
+            action: "undo",
+            params: { record },
+        });
+        return;
+    }
+    if (action === "close" && request.params?.mode === "apply") {
+        const analysisId = request.params.analysisId;
+        const analysis = analysisId ? analyses.get(analysisId) : undefined;
+        if (!analysis) {
+            respond(socket, { ok: false, action, component: "host", version: version_1.VERSION, error: { message: "Unknown analysisId" } });
+            return;
+        }
+        const candidates = analysis.data.candidates || [];
+        const tabIds = candidates.map((candidate) => candidate.tabId).filter(Boolean);
+        const expectedUrls = {};
+        for (const candidate of candidates) {
+            if (candidate.tabId) {
+                expectedUrls[String(candidate.tabId)] = candidate.url;
+            }
+        }
+        if (!tabIds.length) {
+            respond(socket, {
+                ok: true,
+                action,
+                requestId: request.id || null,
+                component: "host",
+                version: version_1.VERSION,
+                data: {
+                    txid: null,
+                    summary: { closedTabs: 0, skippedTabs: 0 },
+                    skipped: [],
+                },
+            });
+            return;
+        }
+        const txid = createId("tx");
+        forwardToExtension(socket, {
+            id: request.id,
+            action: "close",
+            params: {
+                mode: "apply",
+                tabIds,
+                expectedUrls,
+            },
+        }, { txid });
+        return;
+    }
+    if (UNDO_ACTIONS.has(action)) {
+        const txid = createId("tx");
+        forwardToExtension(socket, request, { txid });
+        return;
+    }
+    forwardToExtension(socket, request);
+}
+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 {
+                    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));

package/host/host.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$ROOT/host.js"

package/host/lib/undo.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendUndoRecord = appendUndoRecord;
+exports.readUndoRecords = readUndoRecords;
+exports.filterByRetention = filterByRetention;
+exports.findUndoRecord = findUndoRecord;
+exports.findLatestUndoRecord = findLatestUndoRecord;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DEFAULT_RETENTION_DAYS = 30;
+function appendUndoRecord(filePath, record) {
+    const dir = path_1.default.dirname(filePath);
+    fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs_1.default.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf8");
+}
+function readUndoRecords(filePath) {
+    try {
+        const content = fs_1.default.readFileSync(filePath, "utf8");
+        const lines = content.split("\n").filter(Boolean);
+        const records = [];
+        for (const line of lines) {
+            try {
+                records.push(JSON.parse(line));
+            }
+            catch {
+                // ignore malformed lines
+            }
+        }
+        return records;
+    }
+    catch {
+        return [];
+    }
+}
+function filterByRetention(records, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+    const cutoff = now - retentionDays * 24 * 60 * 60 * 1000;
+    return records.filter((record) => {
+        const createdAt = record.createdAt;
+        return !createdAt || createdAt >= cutoff;
+    });
+}
+function findUndoRecord(filePath, txid, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+    const records = filterByRetention(readUndoRecords(filePath), retentionDays, now);
+    for (let i = records.length - 1; i >= 0; i -= 1) {
+        if (records[i].txid === txid) {
+            return records[i];
+        }
+    }
+    return null;
+}
+function findLatestUndoRecord(filePath, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+    const records = filterByRetention(readUndoRecords(filePath), retentionDays, now);
+    if (!records.length) {
+        return null;
+    }
+    return records[records.length - 1] || null;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "tabctl",
+  "version": "0.1.0",
+  "description": "CLI tool to manage and analyze browser tabs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ekroon/tabctl"
+  },
+  "keywords": [
+    "browser",
+    "tabs",
+    "cli",
+    "edge",
+    "chrome"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "tabctl": "cli/tabctl.js"
+  },
+  "files": [
+    "cli",
+    "host",
+    "shared",
+    "extension"
+  ],
+  "scripts": {
+    "build": "node scripts/gen-version.js && tsc -p tsconfig.json && node scripts/sync-build.js",
+    "bump:major": "node scripts/bump-version.js major",
+    "bump:minor": "node scripts/bump-version.js minor",
+    "bump:patch": "node scripts/bump-version.js patch",
+    "test": "npm run build && node --test tests/unit/*.js",
+    "test:unit": "npm run build && node --test tests/unit/*.js",
+    "test:integration": "node build/scripts/integration-test.js"
+  },
+  "devDependencies": {
+    "@types/chrome": "^0.0.277",
+    "@types/node": "^24",
+    "typescript": "^5.4.5"
+  }
+}

package/shared/config.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetConfig = resetConfig;
+exports.expandEnvVars = expandEnvVars;
+exports.resolveConfig = resolveConfig;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+let cached;
+function resetConfig() {
+    cached = undefined;
+}
+function expandEnvVars(value) {
+    return value.replace(/\$\{(\w+)\}|\$(\w+)/g, (match, braced, bare) => {
+        const varName = braced || bare;
+        return process.env[varName] ?? match;
+    });
+}
+function resolveConfig(profileName) {
+    // Use cache only for no-arg calls (legacy mode)
+    if (!profileName && cached)
+        return cached;
+    // Config dir resolution
+    const configDir = process.env.TABCTL_CONFIG_DIR
+        || path_1.default.join(process.env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), ".config"), "tabctl");
+    // Read optional config.json
+    let fileConfig = {};
+    try {
+        const raw = fs_1.default.readFileSync(path_1.default.join(configDir, "config.json"), "utf-8");
+        fileConfig = JSON.parse(raw);
+    }
+    catch {
+        // missing or malformed — treat as empty
+    }
+    // Data dir resolution
+    let dataDir;
+    if (typeof fileConfig.dataDir === "string" && fileConfig.dataDir) {
+        dataDir = expandEnvVars(fileConfig.dataDir);
+        if (!path_1.default.isAbsolute(dataDir)) {
+            throw new Error(`dataDir in config.json must be an absolute path (got: ${dataDir}). Use $HOME or full paths.`);
+        }
+    }
+    else if (process.env.TABCTL_CONFIG_DIR) {
+        dataDir = path_1.default.join(configDir, "data");
+    }
+    else {
+        dataDir = path_1.default.join(process.env.XDG_STATE_HOME || path_1.default.join(os_1.default.homedir(), ".local", "state"), "tabctl");
+    }
+    const baseDataDir = dataDir;
+    // Profile resolution (read profiles.json inline to avoid circular import)
+    const explicitProfile = profileName;
+    const effectiveProfile = profileName || process.env.TABCTL_PROFILE;
+    let activeProfileName;
+    if (effectiveProfile) {
+        try {
+            const raw = fs_1.default.readFileSync(path_1.default.join(configDir, "profiles.json"), "utf-8");
+            const registry = JSON.parse(raw);
+            const profile = registry.profiles[effectiveProfile];
+            if (profile) {
+                dataDir = profile.dataDir;
+                activeProfileName = effectiveProfile;
+            }
+            else if (explicitProfile) {
+                throw new Error(`Profile "${explicitProfile}" not found in profiles.json`);
+            }
+        }
+        catch (err) {
+            // Re-throw profile-not-found errors
+            if (err instanceof Error && err.message.includes("not found in profiles.json")) {
+                throw err;
+            }
+            // If profiles.json is missing/malformed and profile was explicitly requested, error
+            if (explicitProfile) {
+                throw new Error(`Profile "${explicitProfile}" not found: no profiles.json`);
+            }
+            // Otherwise (env var only), silently fall through to legacy mode
+        }
+    }
+    else {
+        // No explicit profile — check for a default in profiles.json
+        try {
+            const raw = fs_1.default.readFileSync(path_1.default.join(configDir, "profiles.json"), "utf-8");
+            const registry = JSON.parse(raw);
+            if (registry.default && registry.profiles[registry.default]) {
+                dataDir = registry.profiles[registry.default].dataDir;
+                activeProfileName = registry.default;
+            }
+        }
+        catch {
+            // No profiles.json — legacy mode
+        }
+    }
+    const result = {
+        configDir,
+        dataDir,
+        baseDataDir,
+        socketPath: process.env.TABCTL_SOCKET || path_1.default.join(dataDir, "tabctl.sock"),
+        undoLog: path_1.default.join(dataDir, "undo.jsonl"),
+        wrapperDir: dataDir,
+        policyPath: path_1.default.join(configDir, "policy.json"),
+        activeProfileName,
+    };
+    // Only cache no-arg calls
+    if (!profileName) {
+        cached = result;
+    }
+    return result;
+}