tabctl 0.5.3 → 0.6.0-alpha.10

package/dist/extension/lib/content.js

@@ -1,21 +1,10 @@
 "use strict";
 // Content script execution utilities — extracted from background.ts (pure structural refactor).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SETTLE_POLL_INTERVAL_MS = exports.SETTLE_STABILITY_MS = void 0;
-exports.isScriptableUrl = isScriptableUrl;
 exports.delay = delay;
 exports.executeWithTimeout = executeWithTimeout;
 exports.extractPageMeta = extractPageMeta;
 exports.extractSelectorSignal = extractSelectorSignal;
-exports.waitForTabLoad = waitForTabLoad;
-exports.waitForDomReady = waitForDomReady;
-exports.waitForSettle = waitForSettle;
-exports.waitForTabReady = waitForTabReady;
-exports.SETTLE_STABILITY_MS = 500;
-exports.SETTLE_POLL_INTERVAL_MS = 50;
-function isScriptableUrl(url) {
-    return typeof url === "string" && (url.startsWith("http://") || url.startsWith("https://"));
-}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -184,107 +173,3 @@ async function extractSelectorSignal(tabId, specs, timeoutMs, selectorValueMaxLe
     }
     return result;
 }
-function waitForTabLoad(tabId, timeoutMs) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const done = () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            chrome.tabs.onUpdated.removeListener(onUpdated);
-            resolve();
-        };
-        const onUpdated = (updatedTabId, info) => {
-            if (updatedTabId === tabId && info.status === "complete") {
-                done();
-            }
-        };
-        chrome.tabs.onUpdated.addListener(onUpdated);
-        chrome.tabs.get(tabId).then((tab) => {
-            if (tab.status === "complete") {
-                done();
-            }
-        }).catch(() => {
-            done();
-        });
-        setTimeout(done, timeoutMs);
-    });
-}
-async function waitForDomReady(tabId, timeoutMs) {
-    const result = await executeWithTimeout(tabId, timeoutMs, () => {
-        if (document.readyState === "interactive" || document.readyState === "complete") {
-            return true;
-        }
-        return new Promise((resolve) => {
-            const onReady = () => {
-                document.removeEventListener("DOMContentLoaded", onReady);
-                resolve(true);
-            };
-            document.addEventListener("DOMContentLoaded", onReady, { once: true });
-            setTimeout(() => {
-                document.removeEventListener("DOMContentLoaded", onReady);
-                resolve(false);
-            }, Math.max(0, timeoutMs - 50));
-        });
-    });
-    if (result === null) {
-        await delay(Math.min(200, Math.max(50, Math.floor(timeoutMs / 10))));
-    }
-}
-async function waitForSettle(tabId, timeoutMs) {
-    const startTime = Date.now();
-    let lastUrl = "";
-    let lastTitle = "";
-    let stableStart = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-        const tab = await chrome.tabs.get(tabId).catch(() => null);
-        if (!tab)
-            return;
-        const currentUrl = tab.url || "";
-        const currentTitle = tab.title || "";
-        // Reset stability timer if URL or title changed
-        if (currentUrl !== lastUrl || currentTitle !== lastTitle) {
-            lastUrl = currentUrl;
-            lastTitle = currentTitle;
-            stableStart = Date.now();
-        }
-        else if (isScriptableUrl(currentUrl) &&
-            tab.status === "complete" &&
-            Date.now() - stableStart >= exports.SETTLE_STABILITY_MS) {
-            // Page is loaded, URL is valid, and stable for long enough
-            return;
-        }
-        await delay(exports.SETTLE_POLL_INTERVAL_MS);
-    }
-    // Timeout reached, continue anyway
-}
-async function waitForTabReady(tabId, params, fallbackTimeoutMs) {
-    const waitFor = typeof params.waitFor === "string" ? params.waitFor.trim().toLowerCase() : "";
-    if (!waitFor || waitFor === "none") {
-        return;
-    }
-    const timeoutRaw = Number(params.waitTimeoutMs);
-    const timeoutMs = Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.floor(timeoutRaw) : fallbackTimeoutMs;
-    // settle mode handles its own URL checking, so skip the early return
-    if (waitFor === "settle") {
-        await waitForSettle(tabId, timeoutMs);
-        return;
-    }
-    try {
-        const tab = await chrome.tabs.get(tabId);
-        if (!isScriptableUrl(tab.url)) {
-            return;
-        }
-    }
-    catch {
-        return;
-    }
-    if (waitFor === "load") {
-        await waitForTabLoad(tabId, timeoutMs);
-        return;
-    }
-    if (waitFor === "dom") {
-        await waitForDomReady(tabId, timeoutMs);
-    }
-}

package/dist/extension/lib/screenshot.js

@@ -13,7 +13,6 @@ exports.captureVisible = captureVisible;
 exports.getPageMetrics = getPageMetrics;
 exports.scrollToPosition = scrollToPosition;
 exports.captureTabTiles = captureTabTiles;
-exports.screenshotTabs = screenshotTabs;
 exports.SCREENSHOT_TILE_MAX_DIM = 2000;
 exports.SCREENSHOT_MAX_BYTES = 2_000_000;
 exports.SCREENSHOT_QUALITY = 80;
@@ -273,95 +272,3 @@ async function captureTabTiles(tab, options, deps) {
     await scrollToPosition(tabId, exports.SCREENSHOT_PROCESS_TIMEOUT_MS, startScrollX, startScrollY, deps);
     return tiles;
 }
-async function screenshotTabs(params, requestId, deps) {
-    const snapshot = await deps.getTabSnapshot();
-    const selection = deps.selectTabsByScope(snapshot, params);
-    if (selection.error) {
-        throw selection.error;
-    }
-    const mode = params.mode === "full" ? "full" : "viewport";
-    const format = params.format === "jpeg" ? "jpeg" : "png";
-    const qualityRaw = Number(params.quality);
-    const quality = Number.isFinite(qualityRaw) ? Math.min(100, Math.max(0, Math.floor(qualityRaw))) : exports.SCREENSHOT_QUALITY;
-    const tileMaxDimRaw = Number(params.tileMaxDim);
-    const tileMaxDim = Number.isFinite(tileMaxDimRaw) && tileMaxDimRaw > 0 ? Math.floor(tileMaxDimRaw) : exports.SCREENSHOT_TILE_MAX_DIM;
-    const adjustedTileMaxDim = tileMaxDim < 50 ? 50 : tileMaxDim;
-    const maxBytesRaw = Number(params.maxBytes);
-    const maxBytes = Number.isFinite(maxBytesRaw) && maxBytesRaw > 0 ? Math.floor(maxBytesRaw) : exports.SCREENSHOT_MAX_BYTES;
-    const adjustedMaxBytes = maxBytes < 50_000 ? 50_000 : maxBytes;
-    const progressEnabled = params.progress === true;
-    const tabs = selection.tabs;
-    const entries = [];
-    let totalTiles = 0;
-    const startedAt = Date.now();
-    for (let index = 0; index < tabs.length; index += 1) {
-        const tab = tabs[index];
-        const tabId = tab.tabId;
-        const url = tab.url;
-        if (!deps.isScriptableUrl(url)) {
-            entries.push({
-                tabId,
-                windowId: tab.windowId,
-                groupId: tab.groupId,
-                url: tab.url,
-                title: tab.title,
-                error: { message: "unsupported_url" },
-                tiles: [],
-            });
-            if (progressEnabled) {
-                deps.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs.length, tabId });
-            }
-            continue;
-        }
-        let tiles = [];
-        let error = null;
-        try {
-            const windowId = tab.windowId;
-            const activeTabs = await chrome.tabs.query({ windowId, active: true });
-            const activeTabId = activeTabs[0]?.id ?? null;
-            if (activeTabId && activeTabId !== tabId) {
-                await chrome.tabs.update(tabId, { active: true });
-                await deps.delay(exports.SCREENSHOT_SCROLL_DELAY_MS);
-            }
-            try {
-                await deps.waitForTabReady(tabId, params, exports.SCREENSHOT_PROCESS_TIMEOUT_MS);
-                tiles = await captureTabTiles(tab, { mode, format, quality, tileMaxDim: adjustedTileMaxDim, maxBytes: adjustedMaxBytes }, deps);
-            }
-            finally {
-                if (activeTabId && activeTabId !== tabId) {
-                    await chrome.tabs.update(activeTabId, { active: true });
-                }
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : "capture_failed";
-            error = { message };
-        }
-        totalTiles += tiles.length;
-        entries.push({
-            tabId: tab.tabId,
-            windowId: tab.windowId,
-            groupId: tab.groupId,
-            url: tab.url,
-            title: tab.title,
-            tiles,
-            ...(error ? { error } : {}),
-        });
-        if (progressEnabled) {
-            deps.sendProgress(requestId, { phase: "screenshot", processed: index + 1, total: tabs.length, tabId });
-        }
-    }
-    return {
-        generatedAt: Date.now(),
-        totals: { tabs: tabs.length, tiles: totalTiles },
-        meta: {
-            durationMs: Date.now() - startedAt,
-            mode,
-            format,
-            quality: format === "jpeg" ? quality : null,
-            tileMaxDim: adjustedTileMaxDim,
-            maxBytes: adjustedMaxBytes,
-        },
-        entries,
-    };
-}

package/dist/extension/manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabctl",
-  "version": "0.5.3",
+  "version": "0.6.0-alpha.10",
   "description": "CLI tool to manage and analyze browser tabs",
   "license": "MIT",
   "repository": {
@@ -27,13 +27,21 @@
     "dist/extension"
   ],
   "scripts": {
-    "build": "node scripts/gen-version.js && tsc -p tsconfig.json && node scripts/copy-artifacts.js && node scripts/build-launcher.js && node scripts/bundle-extension.js",
+    "build": "node scripts/gen-version.js && tsc -p tsconfig.json && node scripts/copy-artifacts.js && node scripts/bundle-extension.js && cargo build --manifest-path rust/Cargo.toml --workspace",
+    "build:launcher": "node scripts/build-launcher.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 --test-timeout=5000 dist/tests/unit/*.js && node dist/scripts/integration-test.js",
-    "test:unit": "npm run build && node --test --test-timeout=5000 dist/tests/unit/*.js",
-    "test:integration": "node dist/scripts/integration-test.js",
+    "bump:alpha": "node scripts/bump-version.js alpha",
+    "check:targets": "bash scripts/check-targets.sh",
+    "bump:rc": "node scripts/bump-version.js rc",
+    "bump:stable": "node scripts/bump-version.js stable",
+    "rust:check": "cargo check --manifest-path rust/Cargo.toml --workspace --all-targets",
+    "rust:test": "cargo test --manifest-path rust/Cargo.toml --workspace --all-targets",
+    "rust:verify": "cargo fmt --manifest-path rust/Cargo.toml --all -- --check && cargo clippy --manifest-path rust/Cargo.toml --workspace --all-targets -- -D warnings && npm run rust:test",
+    "test": "npm run build && npm run rust:verify",
+    "test:unit": "npm run rust:test",
+    "test:integration": "cargo test --manifest-path rust/Cargo.toml --test browser_integration --test browser_coverage --test browser_primitives --test local_commands -- --ignored --nocapture --test-threads=1",
     "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" ",
     "prepare": "git rev-parse --git-dir >/dev/null 2>&1 && git config core.hooksPath .githooks || true"
   },

package/dist/cli/lib/args.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeGroupColor = normalizeGroupColor;
-exports.normalizeSignals = normalizeSignals;
-exports.validateSignals = validateSignals;
-exports.parseArgs = parseArgs;
-const constants_1 = require("./constants");
-const options_1 = require("./options");
-const output_1 = require("./output");
-function normalizeGroupColor(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim().toLowerCase();
-    if (!trimmed) {
-        return undefined;
-    }
-    if (!constants_1.GROUP_COLORS.has(trimmed)) {
-        (0, output_1.errorOut)(`Invalid color: ${value}. Use one of: ${Array.from(constants_1.GROUP_COLORS).join(", ")}`);
-    }
-    return trimmed;
-}
-function normalizeSignals(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((signal) => String(signal).trim()).filter(Boolean);
-}
-function validateSignals(signals) {
-    for (const signal of signals) {
-        if (!constants_1.SUPPORTED_SIGNAL_SET.has(signal)) {
-            (0, output_1.errorOut)(`Unknown signal: ${signal}. Use one of: ${constants_1.SUPPORTED_SIGNALS.join(", ")}`);
-        }
-    }
-}
-function normalizeCommand(value) {
-    if (!value) {
-        return value;
-    }
-    if (value === "groups" || value === "group") {
-        return "group-list";
-    }
-    const meta = options_1.COMMANDS[value];
-    if (!meta?.aliases || meta.aliases.length === 0) {
-        return value;
-    }
-    return meta.aliases[0] ?? value;
-}
-function parseArgs(argv) {
-    const args = [...argv];
-    let command;
-    const options = { _: [] };
-    const warnings = [];
-    const pendingFlags = [];
-    const allowedFlags = (0, options_1.getAllowedFlags)();
-    const booleanFlags = (0, options_1.getBooleanFlags)();
-    while (args.length > 0) {
-        const arg = args.shift();
-        if (!arg.startsWith("--")) {
-            if (!command) {
-                command = normalizeCommand(arg);
-                if (command) {
-                    const commandAllowedFlags = (0, options_1.getCommandAllowedFlags)(command);
-                    for (const pending of pendingFlags) {
-                        if (!commandAllowedFlags.has(pending)) {
-                            warnings.push(`--${pending} is not supported by ${command}`);
-                        }
-                    }
-                }
-                continue;
-            }
-            options._.push(arg);
-            continue;
-        }
-        const key = arg.slice(2);
-        if (!allowedFlags.has(key)) {
-            if (key === "format") {
-                (0, output_1.errorOut)("Unknown option: --format");
-            }
-            (0, output_1.errorOut)(`Unknown option: --${key}`);
-        }
-        if (command) {
-            const commandAllowedFlags = (0, options_1.getCommandAllowedFlags)(command);
-            if (!commandAllowedFlags.has(key)) {
-                warnings.push(`--${key} is not supported by ${command}`);
-            }
-        }
-        else {
-            pendingFlags.push(key);
-        }
-        // Boolean flags (no value needed)
-        if (booleanFlags.has(key)) {
-            options[key] = true;
-            continue;
-        }
-        // Value required
-        const value = args.shift();
-        if (value == null) {
-            (0, output_1.errorOut)(`Missing value for --${key}`);
-        }
-        // Repeatable flags (accumulate into arrays)
-        if (key === "signal") {
-            if (!options.signal) {
-                options.signal = [];
-            }
-            options.signal.push(value);
-            continue;
-        }
-        if (key === "tab") {
-            if (!options.tab) {
-                options.tab = [];
-            }
-            options.tab.push(value);
-            continue;
-        }
-        if (key === "agent") {
-            if (!options.agent) {
-                options.agent = [];
-            }
-            options.agent.push(value);
-            continue;
-        }
-        if (key === "url") {
-            if (!options.url) {
-                options.url = [];
-            }
-            options.url.push(value);
-            continue;
-        }
-        if (key === "selector") {
-            if (!options.selector) {
-                options.selector = [];
-            }
-            options.selector.push(value);
-            continue;
-        }
-        // Single value flags
-        options[key] = value;
-    }
-    return { command, options, warnings };
-}

package/dist/cli/lib/client.js

@@ -1,83 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRequestId = createRequestId;
-exports.sendRequest = sendRequest;
-exports.fetchSnapshot = fetchSnapshot;
-exports.sendFireAndForget = sendFireAndForget;
-const node_net_1 = __importDefault(require("node:net"));
-const constants_1 = require("./constants");
-function createRequestId() {
-    return `req-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-}
-function sendRequest(payload, onProgress) {
-    return new Promise((resolve, reject) => {
-        const { socketPath } = (0, constants_1.resolveConfig)();
-        const client = node_net_1.default.createConnection(socketPath);
-        let buffer = "";
-        client.on("connect", () => {
-            client.write(`${JSON.stringify(payload)}\n`);
-        });
-        client.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 response;
-                try {
-                    response = JSON.parse(line);
-                }
-                catch (error) {
-                    client.end();
-                    client.destroy();
-                    reject(error);
-                    return;
-                }
-                if (response.progress && onProgress) {
-                    onProgress(response);
-                    continue;
-                }
-                client.end();
-                client.destroy();
-                resolve(response);
-                return;
-            }
-        });
-        client.on("error", (error) => {
-            reject(error);
-        });
-    });
-}
-async function fetchSnapshot() {
-    const response = await sendRequest({ id: createRequestId(), action: "list", params: {} });
-    if (!response.ok) {
-        return null;
-    }
-    return response.data;
-}
-/** Send a request without waiting for a response (fire-and-forget). */
-function sendFireAndForget(payload) {
-    try {
-        const { socketPath } = (0, constants_1.resolveConfig)();
-        const client = node_net_1.default.createConnection(socketPath);
-        client.on("connect", () => {
-            client.write(`${JSON.stringify(payload)}\n`);
-            // Unref after write so Node can exit without waiting for response
-            client.unref();
-            const timer = setTimeout(() => { client.end(); client.destroy(); }, 200);
-            timer.unref();
-        });
-        client.on("error", () => {
-            // Silently ignore — this is best-effort
-        });
-    }
-    catch {
-        // Silently ignore
-    }
-}

package/dist/cli/lib/commands/doctor.js

@@ -1,134 +0,0 @@
-"use strict";
-/**
- * Doctor command handler: diagnose and repair profile health.
- *
- * Checks each profile's wrapper for valid Node/host paths, verifies
- * extension sync status, and optionally auto-repairs broken wrappers.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDoctor = runDoctor;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("../../../shared/config");
-const profiles_1 = require("../../../shared/profiles");
-const wrapper_health_1 = require("../../../shared/wrapper-health");
-const extension_sync_1 = require("../../../shared/extension-sync");
-const setup_1 = require("./setup");
-const output_1 = require("../output");
-function checkProfile(name, entry, fix) {
-    const wrapperPath = (0, wrapper_health_1.resolveWrapperPath)(entry.dataDir);
-    const check = (0, wrapper_health_1.checkWrapper)(wrapperPath);
-    const issues = [...check.issues];
-    let fixed = false;
-    if (fix && !check.ok && check.info) {
-        const needsNodeFix = !node_fs_1.default.existsSync(check.info.nodePath);
-        const needsHostFix = !node_fs_1.default.existsSync(check.info.hostPath);
-        if (needsNodeFix || needsHostFix) {
-            const newNodePath = needsNodeFix ? process.execPath : check.info.nodePath;
-            let newHostPath = check.info.hostPath;
-            if (needsHostFix) {
-                // Use the stable bundled host path
-                try {
-                    const config = (0, config_1.resolveConfig)();
-                    newHostPath = (0, extension_sync_1.resolveInstalledHostPath)(config.baseDataDir);
-                    if (!node_fs_1.default.existsSync(newHostPath)) {
-                        issues.push(`Bundled host not found at ${newHostPath} — run: tabctl setup --browser ${entry.browser}`);
-                    }
-                }
-                catch {
-                    issues.push("Could not resolve bundled host path");
-                }
-            }
-            try {
-                (0, setup_1.writeWrapper)(newNodePath, newHostPath, check.info.profileName, node_path_1.default.dirname(wrapperPath));
-                fixed = true;
-                // Update issue messages to show they were fixed
-                const fixedIssues = [];
-                if (needsNodeFix) {
-                    fixedIssues.push(`Fixed Node path: ${check.info.nodePath} → ${newNodePath}`);
-                }
-                if (needsHostFix) {
-                    fixedIssues.push(`Fixed host path: ${check.info.hostPath} → ${newHostPath}`);
-                }
-                // Replace original issues with fixed messages
-                issues.length = 0;
-                issues.push(...fixedIssues);
-            }
-            catch (err) {
-                issues.push(`Failed to fix wrapper: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-    return {
-        ok: check.ok || fixed,
-        browser: entry.browser,
-        dataDir: entry.dataDir,
-        wrapperPath,
-        issues,
-        fixed,
-    };
-}
-function runDoctor(options, prettyOutput) {
-    const fix = options.fix === true;
-    const config = (0, config_1.resolveConfig)();
-    const registry = (0, profiles_1.loadProfiles)(config.configDir);
-    const profileNames = Object.keys(registry.profiles);
-    if (profileNames.length === 0) {
-        (0, output_1.errorOut)("No profiles configured. Run: tabctl setup --browser <edge|chrome>");
-    }
-    // Check each profile
-    const profiles = {};
-    for (const name of profileNames) {
-        profiles[name] = checkProfile(name, registry.profiles[name], fix);
-    }
-    // Check extension sync status
-    let extensionCheck;
-    try {
-        const sync = (0, extension_sync_1.checkExtensionSync)(config.baseDataDir);
-        extensionCheck = {
-            ok: !sync.needsSync,
-            synced: !sync.needsSync,
-            bundledVersion: sync.bundledVersion,
-            installedVersion: sync.installedVersion,
-        };
-    }
-    catch {
-        extensionCheck = {
-            ok: false,
-            synced: false,
-            bundledVersion: null,
-            installedVersion: null,
-        };
-    }
-    // Summary
-    const total = profileNames.length;
-    const healthy = Object.values(profiles).filter(p => p.ok).length;
-    const broken = total - healthy;
-    const fixed = Object.values(profiles).filter(p => p.fixed).length;
-    const allOk = broken === 0 && extensionCheck.ok;
-    (0, output_1.printJson)({
-        ok: allOk,
-        action: "doctor",
-        data: {
-            profiles,
-            extension: extensionCheck,
-            summary: { total, healthy, broken, fixed },
-        },
-    }, prettyOutput);
-    // Helpful stderr hints
-    if (!allOk && !fix) {
-        const brokenNames = Object.entries(profiles)
-            .filter(([, p]) => !p.ok)
-            .map(([n]) => n);
-        if (brokenNames.length > 0) {
-            process.stderr.write(`\nBroken profiles: ${brokenNames.join(", ")}\n`);
-            process.stderr.write("Run: tabctl doctor --fix\n\n");
-        }
-    }
-    if (fixed > 0) {
-        process.stderr.write(`\nFixed ${fixed} profile(s). Verify: tabctl ping\n\n`);
-    }
-}