tabctl 0.1.4 → 0.2.1

package/dist/cli/tabctl.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const policy_1 = require("./lib/policy");
+const constants_1 = require("./lib/constants");
+const output_1 = require("./lib/output");
+const args_1 = require("./lib/args");
+const client_1 = require("./lib/client");
+const help_1 = require("./lib/help");
+const response_1 = require("./lib/response");
+const policy_filter_1 = require("./lib/policy-filter");
+const commands_1 = require("./lib/commands");
+const commands_2 = require("./lib/commands");
+const createId = client_1.createRequestId;
+async function main() {
+    (0, output_1.setupStdoutErrorHandling)();
+    let { command, options, warnings } = (0, args_1.parseArgs)(process.argv.slice(2));
+    if (typeof options.profile === "string" && options.profile) {
+        process.env.TABCTL_PROFILE = options.profile;
+    }
+    if (command === "dedupe" && options.close) {
+        (0, output_1.errorOut)("dedupe does not support --close; use --confirm or close --apply <analysisId>.");
+    }
+    const prettyOutput = options.pretty !== false;
+    if (command === "groups" || command === "group") {
+        command = "group-list";
+    }
+    if (command === "profile" || command === "profiles") {
+        command = "profile-list";
+    }
+    if (command === "list" && options.groups === true) {
+        command = "group-list";
+    }
+    if (options.format && command !== "report" && command !== "screenshot") {
+        (0, output_1.errorOut)("Unknown option: --format");
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "policy")) {
+        (0, output_1.errorOut)("Custom policy path is not supported. Use XDG_CONFIG_HOME/tabctl/policy.json.");
+    }
+    if (command === "refresh") {
+        const tabValues = Array.isArray(options.tab)
+            ? options.tab.map((value) => String(value).trim()).filter(Boolean)
+            : [];
+        if (tabValues.length === 0) {
+            (0, output_1.errorOut)("refresh requires --tab");
+        }
+        if (tabValues.length > 1) {
+            (0, output_1.errorOut)("refresh requires a single --tab");
+        }
+    }
+    if (command === "open" && options.color && !options.group) {
+        (0, output_1.errorOut)("--color requires --group");
+    }
+    if (command === "undo") {
+        if (options.txid && options._.length > 0) {
+            (0, output_1.errorOut)("undo requires a single txid (use positional arg or --txid)");
+        }
+        if (options.latest === true && options._.length > 0) {
+            (0, output_1.errorOut)("undo --latest cannot be combined with a txid");
+        }
+        if (options.latest === true && options.txid) {
+            (0, output_1.errorOut)("undo --latest cannot be combined with --txid");
+        }
+        if (options.txid && options._.length === 0) {
+            options._ = [String(options.txid)];
+        }
+    }
+    if (command === "inspect") {
+        const selectorCount = Array.isArray(options.selector) ? options.selector.length : 0;
+        if (selectorCount > 0) {
+            const signalList = (0, args_1.normalizeSignals)(options.signal);
+            if (!signalList.includes("selector")) {
+                signalList.push("selector");
+            }
+            options.signal = signalList;
+        }
+        const signalList = (0, args_1.normalizeSignals)(options.signal);
+        if (signalList.length > 0) {
+            (0, args_1.validateSignals)(signalList);
+            options.signal = signalList;
+        }
+    }
+    if (command === "screenshot") {
+        const mode = options.mode != null ? String(options.mode).trim().toLowerCase() : "viewport";
+        const format = options.format != null ? String(options.format).trim().toLowerCase() : "png";
+        if (mode !== "viewport" && mode !== "full") {
+            (0, output_1.errorOut)("Invalid --mode value (use viewport or full)");
+        }
+        if (format !== "png" && format !== "jpeg") {
+            (0, output_1.errorOut)("Invalid --format value (use png or jpeg)");
+        }
+        if (format === "jpeg" && options.quality == null) {
+            options.quality = 80;
+        }
+        const qualityRaw = options.quality != null ? Number(options.quality) : null;
+        if (qualityRaw != null && (!Number.isFinite(qualityRaw) || qualityRaw < 0 || qualityRaw > 100)) {
+            (0, output_1.errorOut)("Invalid --quality value (use 0-100)");
+        }
+        if (qualityRaw != null && format !== "jpeg") {
+            (0, output_1.errorOut)("--quality requires --format jpeg");
+        }
+        const tileMaxDimRaw = options["tile-max-dim"] != null ? Number(options["tile-max-dim"]) : null;
+        if (tileMaxDimRaw != null && (!Number.isFinite(tileMaxDimRaw) || tileMaxDimRaw <= 0)) {
+            (0, output_1.errorOut)("Invalid --tile-max-dim value");
+        }
+        const maxBytesRaw = options["max-bytes"] != null ? Number(options["max-bytes"]) : null;
+        if (maxBytesRaw != null && (!Number.isFinite(maxBytesRaw) || maxBytesRaw <= 0)) {
+            (0, output_1.errorOut)("Invalid --max-bytes value");
+        }
+        if (mode === "viewport" && options["tile-max-dim"] != null) {
+            (0, output_1.errorOut)("--tile-max-dim requires --mode full");
+        }
+        if (mode === "viewport" && options["max-bytes"] != null) {
+            (0, output_1.errorOut)("--max-bytes requires --mode full");
+        }
+        if (options.mode == null) {
+            options.mode = "viewport";
+        }
+        if (options.format == null) {
+            options.format = "png";
+        }
+    }
+    const policyContext = (0, policy_1.loadPolicy)();
+    const policySummary = (0, policy_1.summarizePolicy)(policyContext.policy, policyContext.path);
+    const policyEnabled = policyContext.policy !== null;
+    const enforcePolicy = policyEnabled;
+    const includeWindowTitle = options["window-title"] === true;
+    const includeStale = options["include-stale"] === true;
+    let policySnapshot = null;
+    const getPolicySnapshot = async () => {
+        if (!policySnapshot) {
+            policySnapshot = await (0, client_1.fetchSnapshot)();
+        }
+        return policySnapshot;
+    };
+    if (!command || command === "help" || options.help) {
+        const helpTarget = command === "help"
+            ? (options._.length > 0 ? String(options._[0]) : undefined)
+            : command;
+        (0, help_1.printHelp)(options.json === true, helpTarget);
+        return;
+    }
+    if (warnings.length > 0) {
+        for (const warning of warnings) {
+            process.stderr.write(`[tabctl] warning: ${warning}\n`);
+        }
+    }
+    if (command === "skill") {
+        (0, commands_1.runSkillInstall)(options, prettyOutput);
+        return;
+    }
+    if (command === "setup") {
+        await (0, commands_1.runSetup)(options, prettyOutput);
+        return;
+    }
+    if (command === "version") {
+        (0, commands_1.runVersion)(prettyOutput);
+        return;
+    }
+    if (command === "policy") {
+        (0, commands_1.runPolicy)(options, policyContext, prettyOutput);
+        return;
+    }
+    if (command === "ping") {
+        await (0, commands_1.runPing)(prettyOutput);
+        return;
+    }
+    if (command === "history") {
+        await (0, commands_1.runHistory)(options, prettyOutput);
+        return;
+    }
+    if (command === "undo") {
+        await (0, commands_1.runUndo)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-list") {
+        (0, commands_1.runProfileList)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-show") {
+        (0, commands_1.runProfileShow)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-switch") {
+        (0, commands_1.runProfileSwitch)(options, prettyOutput);
+        return;
+    }
+    if (command === "profile-remove") {
+        (0, commands_1.runProfileRemove)(options, prettyOutput);
+        return;
+    }
+    if (command === "list") {
+        await (0, commands_1.runList)(options, policyContext, policySummary, prettyOutput);
+        return;
+    }
+    if (command === "group-list") {
+        await (0, commands_1.runGroupList)(options, policyContext, policySummary, prettyOutput);
+        return;
+    }
+    let dedupeMode = false;
+    if (command === "close" && options["dry-run"]) {
+        command = "analyze";
+    }
+    if (command === "dedupe") {
+        dedupeMode = true;
+        command = "analyze";
+    }
+    let action = command;
+    let params = {};
+    let policyInfo = null;
+    let earlyResponse = null;
+    switch (command) {
+        case "analyze":
+            action = "analyze";
+            params = (0, commands_2.buildAnalyzeParams)(options);
+            break;
+        case "inspect":
+            action = "inspect";
+            params = (0, commands_2.buildInspectParams)(options);
+            break;
+        case "focus":
+            action = "focus";
+            params = (0, commands_2.buildFocusParams)(options);
+            break;
+        case "refresh":
+            action = "refresh";
+            params = (0, commands_2.buildRefreshParams)(options);
+            break;
+        case "open":
+            action = "open";
+            params = (0, commands_2.buildOpenParams)(options);
+            break;
+        case "group-update":
+            action = "group-update";
+            params = (0, commands_2.buildGroupUpdateParams)(options);
+            break;
+        case "group-ungroup":
+            action = "group-ungroup";
+            params = (0, commands_2.buildGroupUngroupParams)(options);
+            break;
+        case "group-assign":
+            action = "group-assign";
+            params = (0, commands_2.buildGroupAssignParams)(options);
+            break;
+        case "move-tab":
+            action = "move-tab";
+            params = (0, commands_2.buildMoveTabParams)(options);
+            break;
+        case "move-group":
+            action = "move-group";
+            params = (0, commands_2.buildMoveGroupParams)(options);
+            break;
+        case "merge-window":
+            action = "merge-window";
+            params = (0, commands_2.buildMergeWindowParams)(options);
+            break;
+        case "archive":
+            action = "archive";
+            params = (0, commands_2.buildArchiveParams)(options);
+            break;
+        case "close":
+            action = "close";
+            params = (0, commands_2.buildCloseParams)(options);
+            break;
+        case "report":
+            action = "report";
+            params = (0, commands_2.buildReportParams)(options);
+            break;
+        case "screenshot":
+            action = "screenshot";
+            params = (0, commands_2.buildScreenshotParams)(options);
+            break;
+        default:
+            (0, output_1.errorOut)(`Unknown command: ${command}`);
+    }
+    if (command === "analyze") {
+        const tabIds = params.tabIds;
+        const windowId = params.windowId;
+        const hasScope = (Array.isArray(tabIds) && tabIds.length > 0)
+            || Boolean(params.groupTitle)
+            || Number.isFinite(params.groupId)
+            || (typeof windowId === "number" && Number.isFinite(windowId))
+            || (typeof windowId === "string" && windowId.length > 0)
+            || params.all === true;
+        if (!hasScope) {
+            params = { ...params, all: true };
+        }
+    }
+    if (command === "merge-window") {
+        const fromWindowId = params.fromWindowId;
+        const toWindowId = params.toWindowId;
+        if (!Number.isFinite(fromWindowId) || !Number.isFinite(toWindowId)) {
+            (0, output_1.errorOut)("merge-window requires --from and --to window ids");
+        }
+        if (fromWindowId === toWindowId) {
+            (0, output_1.errorOut)("merge-window --from and --to cannot be the same window");
+        }
+        if (params.closeSource && !params.confirmed) {
+            (0, output_1.errorOut)("merge-window --close-source requires --confirm");
+        }
+    }
+    if (enforcePolicy && ["analyze", "inspect", "report", "screenshot", "close", "archive", "focus", "refresh", "move-tab", "move-group", "group-assign", "group-update", "group-ungroup", "merge-window"].includes(command)) {
+        if (command === "close" && options.apply) {
+            (0, output_1.errorOut)("Policy blocks close --apply; use explicit tab targets.");
+        }
+        const snapshot = await getPolicySnapshot();
+        if (!snapshot) {
+            (0, output_1.errorOut)("Failed to load tabs for policy evaluation");
+        }
+        const filterResult = (0, policy_filter_1.applyPolicyFilter)(command, params, snapshot, policyContext, policySummary);
+        if (filterResult.earlyResponse && !filterResult.earlyResponse.ok) {
+            (0, output_1.printJson)(filterResult.earlyResponse, prettyOutput);
+            process.exit(1);
+        }
+        params = filterResult.params;
+        policyInfo = filterResult.policyInfo;
+        earlyResponse = filterResult.earlyResponse;
+    }
+    const request = {
+        id: createId(),
+        action,
+        params,
+        client: {
+            component: "cli",
+            version: constants_1.VERSION,
+            baseVersion: constants_1.BASE_VERSION,
+            gitSha: constants_1.GIT_SHA,
+            dirty: constants_1.DIRTY,
+        },
+    };
+    let response;
+    const showProgress = options.progress === true;
+    const startedAt = Date.now();
+    let progressTimer = null;
+    if (showProgress) {
+        progressTimer = setInterval(() => {
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            process.stderr.write(`[tabctl] waiting ${elapsed}s...\n`);
+        }, 2000);
+    }
+    const onProgress = showProgress
+        ? (message) => {
+            const data = message.data;
+            if (data?.phase === "github") {
+                const processed = data.processed;
+                const total = data.total;
+                const matched = data.matched;
+                process.stderr.write(`[tabctl] github ${processed}/${total} (matched ${matched})\n`);
+            }
+            if (data?.phase === "inspect") {
+                const processed = data.processed;
+                const total = data.total;
+                const signalId = data.signalId;
+                process.stderr.write(`[tabctl] inspect ${processed}/${total} (${signalId})\n`);
+            }
+            if (data?.phase === "screenshot") {
+                const processed = data.processed;
+                const total = data.total;
+                process.stderr.write(`[tabctl] screenshot ${processed}/${total}\n`);
+            }
+        }
+        : undefined;
+    if (earlyResponse) {
+        response = earlyResponse;
+    }
+    else {
+        try {
+            response = await (0, client_1.sendRequest)(request, onProgress);
+        }
+        catch (error) {
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+            const message = error instanceof Error ? error.message : "Unknown error";
+            (0, output_1.errorOut)(`Failed to connect to host: ${message}`);
+            return;
+        }
+        finally {
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+        }
+    }
+    if (progressTimer) {
+        clearInterval(progressTimer);
+    }
+    if (!response) {
+        (0, output_1.errorOut)("No response received");
+    }
+    if (!response.ok) {
+        (0, output_1.printJson)(response, prettyOutput);
+        process.exit(1);
+    }
+    if (response.data && typeof response.data === "object") {
+        const data = response.data;
+        if ((command === "inspect" || command === "report" || command === "screenshot") && Array.isArray(data.entries)) {
+            let snapshot = null;
+            if (policyEnabled) {
+                snapshot = await getPolicySnapshot();
+            }
+            (0, response_1.annotateEntries)(data, options, command, policyEnabled, policyContext.policy, snapshot);
+        }
+        if (command === "analyze" && Array.isArray(data.candidates)) {
+            let snapshot = null;
+            if (policyEnabled || includeWindowTitle) {
+                snapshot = await getPolicySnapshot();
+            }
+            (0, response_1.annotateCandidates)(data, policyContext.policy, includeWindowTitle, snapshot);
+        }
+        data.policy = policySummary;
+        if (policyInfo) {
+            data.policyInfo = policyInfo;
+        }
+    }
+    else if (response.ok) {
+        response.policy = policySummary;
+    }
+    if (dedupeMode) {
+        if (!response.ok) {
+            (0, output_1.printJson)(response, prettyOutput);
+            return;
+        }
+        const { planTabIds, expectedUrls } = (0, response_1.extractDedupePlan)(response, includeStale);
+        let closeData = null;
+        if (options.confirm === true && planTabIds.length > 0) {
+            const closeResponse = await (0, client_1.sendRequest)({
+                id: createId(),
+                action: "close",
+                params: {
+                    mode: "direct",
+                    confirmed: true,
+                    tabIds: planTabIds,
+                    expectedUrls,
+                },
+            });
+            if (!closeResponse.ok) {
+                (0, output_1.printJson)(closeResponse, prettyOutput);
+                return;
+            }
+            closeData = closeResponse.data || {};
+            closeData.policy = policySummary;
+            if (policyInfo) {
+                closeData.policyInfo = policyInfo;
+            }
+        }
+        const output = (0, response_1.buildDedupeOutput)(response, includeStale, closeData, options.confirm === true);
+        (0, output_1.printJson)(output, prettyOutput);
+        return;
+    }
+    if (command === "report") {
+        (0, response_1.formatReport)(response, options, prettyOutput);
+        return;
+    }
+    if (command === "screenshot") {
+        (0, response_1.writeScreenshots)(response, options, prettyOutput);
+        return;
+    }
+    (0, output_1.emitVersionWarnings)(response, command);
+    (0, output_1.printJson)(response, prettyOutput);
+}
+main().catch((error) => {
+    (0, output_1.errorOut)(error.message || "Unknown error");
+});