@woopsy/mcpanel 1.0.0

package/dist/managers/backupManager.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const configManager_1 = require("../config/configManager");
+const logger_1 = require("../utils/logger");
+class BackupManager {
+    configManager;
+    constructor(configManager) {
+        this.configManager = configManager;
+    }
+    /**
+     * Creates a zipped backup of the managed server.
+     */
+    createBackup() {
+        const server = this.configManager.getServer();
+        if (!server) {
+            throw new Error('No server is connected.');
+        }
+        const serverPath = path.resolve(server.path);
+        if (!fs.existsSync(serverPath)) {
+            throw new Error(`Server path "${serverPath}" does not exist.`);
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupFileName = `${server.name}_backup_${timestamp}.zip`;
+        const backupDestDir = path.join(configManager_1.APP_ROOT, 'backups');
+        if (!fs.existsSync(backupDestDir)) {
+            fs.mkdirSync(backupDestDir, { recursive: true });
+        }
+        const backupPath = path.join(backupDestDir, backupFileName);
+        logger_1.logger.info(`Creating backup for server "${server.name}" to ${backupPath}...`);
+        const zip = new adm_zip_1.default();
+        zip.addLocalFolder(serverPath);
+        zip.writeZip(backupPath);
+        const stats = fs.statSync(backupPath);
+        const meta = {
+            id: `${server.name}_${timestamp}`,
+            name: backupFileName,
+            serverName: server.name,
+            sizeBytes: stats.size,
+            createdAt: new Date().toISOString(),
+            path: backupPath,
+        };
+        logger_1.logger.info(`Backup created successfully: ${backupFileName} (${(stats.size / (1024 * 1024)).toFixed(2)} MB)`);
+        return meta;
+    }
+    /**
+     * Lists all available backups in the local backups directory and synced backup locations.
+     */
+    listBackups() {
+        const backups = [];
+        const scanDirs = [
+            path.join(configManager_1.APP_ROOT, 'backups'),
+            ...this.configManager.getConfig().externalBackups
+        ];
+        for (const dir of scanDirs) {
+            if (!fs.existsSync(dir))
+                continue;
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                if (!file.endsWith('.zip'))
+                    continue;
+                const filePath = path.join(dir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    // Parse server name and timestamp from filename: ServerName_backup_YYYY-MM-DD...
+                    let serverName = 'Unknown';
+                    if (file.includes('_backup_')) {
+                        serverName = file.split('_backup_')[0];
+                    }
+                    // Use file stats for timestamp if we can't extract it easily
+                    const createdAt = stats.mtime.toISOString();
+                    const id = file.replace('.zip', '');
+                    backups.push({
+                        id,
+                        name: file,
+                        serverName,
+                        sizeBytes: stats.size,
+                        createdAt,
+                        path: filePath,
+                    });
+                }
+                catch (err) {
+                    // Ignore issues reading single file stats
+                }
+            }
+        }
+        // Sort backups by creation time descending (newest first)
+        return backups.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    /**
+     * Synchronizes an external backup directory.
+     */
+    syncBackup(dirPath) {
+        const resolvedPath = path.resolve(dirPath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Backup directory "${resolvedPath}" does not exist.`);
+        }
+        this.configManager.addExternalBackup(resolvedPath);
+        // Count .zip files found
+        const files = fs.readdirSync(resolvedPath);
+        const backupZips = files.filter(f => f.endsWith('.zip'));
+        logger_1.logger.info(`Synchronized backup source: ${resolvedPath} (${backupZips.length} backups found)`);
+        return backupZips.length;
+    }
+    /**
+     * Restores a backup safely, unzipping contents and avoiding directory traversal.
+     */
+    restoreBackup(backupId) {
+        const server = this.configManager.getServer();
+        if (!server) {
+            throw new Error('No server is connected.');
+        }
+        const backups = this.listBackups();
+        const backup = backups.find(b => b.id === backupId || b.name === backupId);
+        if (!backup) {
+            throw new Error(`Backup "${backupId}" was not found.`);
+        }
+        const serverDir = path.resolve(server.path);
+        const zipPath = path.resolve(backup.path);
+        logger_1.logger.warn(`Restoring backup "${backup.name}" to server "${server.name}" at ${serverDir}`);
+        if (!fs.existsSync(zipPath)) {
+            throw new Error(`Backup file "${zipPath}" no longer exists on disk.`);
+        }
+        // --- SECURE ZIP EXTRACTION (Zip Slip Prevention) ---
+        const zip = new adm_zip_1.default(zipPath);
+        for (const entry of zip.getEntries()) {
+            // Resolve target path of this entry
+            const entryName = entry.entryName;
+            const targetPath = path.resolve(serverDir, entryName);
+            // Verify directory boundary (prevent directory traversal)
+            if (!targetPath.startsWith(serverDir + path.sep) && targetPath !== serverDir) {
+                logger_1.logger.error(`[SECURITY] Blocked potential Zip Slip: entry "${entryName}" resolves to "${targetPath}" which is outside "${serverDir}"`);
+                throw new Error('Restoration aborted: Corrupted or malicious zip archive containing path traversal entries was detected.');
+            }
+        }
+        // Cleanup server directory first to remove current state files
+        logger_1.logger.info(`Clearing server directory "${serverDir}" before restoration...`);
+        this.clearDirectoryContent(serverDir);
+        // Extract files safely
+        logger_1.logger.info(`Extracting backup archive contents to "${serverDir}"...`);
+        zip.extractAllTo(serverDir, true);
+        logger_1.logger.info(`Server "${server.name}" has been successfully restored from backup "${backup.name}"`);
+    }
+    /**
+     * Helper to clean directory contents without removing the directory itself.
+     */
+    clearDirectoryContent(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            try {
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory()) {
+                    fs.rmSync(filePath, { recursive: true, force: true });
+                }
+                else {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch (err) {
+                logger_1.logger.error(`Failed to delete "${filePath}" during directory cleanup`, err);
+            }
+        }
+    }
+}
+exports.BackupManager = BackupManager;

package/dist/managers/playitManager.js

@@ -0,0 +1,450 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayitManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const child_process_1 = require("child_process");
+const configManager_1 = require("../config/configManager");
+const helpers_1 = require("../utils/helpers");
+const downloadService_1 = require("../services/downloadService");
+const logger_1 = require("../utils/logger");
+// playit agent version this manager targets. Bump to force a re-download.
+const PLAYIT_VERSION = '1.0.8';
+const PLAYIT_API = 'https://api.playit.gg';
+/** Strips ANSI colour / cursor escape sequences that the playit binaries emit. */
+function stripAnsi(input) {
+    return input
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+        .replace(/\x1b[78]/g, '')
+        .replace(/\x1b[()][AB012]/g, '');
+}
+class PlayitManager {
+    configManager;
+    playitProcess = null;
+    claimProcess = null;
+    tunnelStatus;
+    constructor(configManager) {
+        this.configManager = configManager;
+        this.tunnelStatus = this.offlineStatus();
+    }
+    offlineStatus() {
+        return {
+            address: 'None',
+            port: 'None',
+            status: 'Offline',
+            latency: 'N/A',
+            type: null,
+            claimUrl: null,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Binary management (v1.0.8: split into the agent daemon + the control cli)
+    // ---------------------------------------------------------------------------
+    /** Path to the agent/daemon binary (used as the traffic relay). */
+    getExecutablePath() {
+        const osType = (0, helpers_1.detectOS)();
+        const binName = osType === 'Windows' ? 'playit.exe' : 'playit';
+        return path.join(configManager_1.APP_ROOT, 'playit', binName);
+    }
+    /** Path to the control cli (used for the one-time claim flow). */
+    getCliPath() {
+        const osType = (0, helpers_1.detectOS)();
+        // v1.0.8 only ships a separate cli for Linux; on Windows the main exe is used.
+        if (osType === 'Windows')
+            return this.getExecutablePath();
+        return path.join(configManager_1.APP_ROOT, 'playit', 'playit-cli');
+    }
+    /** IPC socket / named pipe the daemon binds to (its default location may not exist). */
+    getSocketPath() {
+        const osType = (0, helpers_1.detectOS)();
+        if (osType === 'Windows')
+            return '\\\\.\\pipe\\mcpanel-playit';
+        return path.join(configManager_1.APP_ROOT, 'playit', 'agent.sock');
+    }
+    getVersionSentinel() {
+        return path.join(configManager_1.APP_ROOT, 'playit', '.version');
+    }
+    downloadUrls() {
+        const base = `https://github.com/playit-cloud/playit-agent/releases/download/v${PLAYIT_VERSION}`;
+        if ((0, helpers_1.detectOS)() === 'Windows') {
+            return { agent: `${base}/playit-windows-x86_64.exe`, cli: null };
+        }
+        return { agent: `${base}/playit-linux-amd64`, cli: `${base}/playit-cli-linux-amd64` };
+    }
+    /** True when both required binaries exist AND match the targeted version. */
+    isBinaryPresent() {
+        if (!fs.existsSync(this.getExecutablePath()))
+            return false;
+        const cli = this.getCliPath();
+        if (cli !== this.getExecutablePath() && !fs.existsSync(cli))
+            return false;
+        try {
+            return fs.readFileSync(this.getVersionSentinel(), 'utf-8').trim() === PLAYIT_VERSION;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Downloads (or upgrades) the playit agent + cli for the detected platform. */
+    async downloadBinary(onProgress) {
+        const osType = (0, helpers_1.detectOS)();
+        const binPath = this.getExecutablePath();
+        const playitDir = path.dirname(binPath);
+        const urls = this.downloadUrls();
+        if (!fs.existsSync(playitDir)) {
+            fs.mkdirSync(playitDir, { recursive: true });
+        }
+        const fetchTo = async (url, dest) => {
+            const tmp = `${dest}.tmp`;
+            await (0, downloadService_1.downloadFile)(url, tmp, (downloaded, total) => {
+                if (onProgress && total > 0)
+                    onProgress(Math.round((downloaded / total) * 100));
+            });
+            fs.renameSync(tmp, dest);
+            if (osType !== 'Windows') {
+                try {
+                    fs.chmodSync(dest, 0o755);
+                }
+                catch (err) {
+                    logger_1.logger.error('chmod failed', err);
+                }
+            }
+        };
+        logger_1.logger.info(`Downloading playit agent v${PLAYIT_VERSION} for ${osType}...`);
+        await fetchTo(urls.agent, binPath);
+        if (urls.cli) {
+            logger_1.logger.info('Downloading playit control cli...');
+            await fetchTo(urls.cli, this.getCliPath());
+        }
+        fs.writeFileSync(this.getVersionSentinel(), PLAYIT_VERSION, 'utf-8');
+        logger_1.logger.info(`Playit binaries ready (v${PLAYIT_VERSION}).`);
+        return binPath;
+    }
+    async ensureBinary() {
+        if (!this.isBinaryPresent()) {
+            logger_1.logger.info('Playit binary missing or outdated. Downloading...');
+            await this.downloadBinary();
+        }
+    }
+    getSecret() {
+        return this.configManager.getConfig().playitSettings.secret || null;
+    }
+    // ---------------------------------------------------------------------------
+    // playit HTTP API (authenticated with the agent secret)
+    // ---------------------------------------------------------------------------
+    apiPost(apiPath, body, secret) {
+        const payload = JSON.stringify(body || {});
+        const url = new URL(PLAYIT_API + apiPath);
+        return new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: url.hostname,
+                path: url.pathname,
+                method: 'POST',
+                headers: {
+                    'Authorization': `agent-key ${secret}`,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload),
+                },
+            }, (res) => {
+                let data = '';
+                res.on('data', (c) => { data += c; });
+                res.on('end', () => {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        reject(new Error(`Bad API response: ${data.slice(0, 200)}`));
+                        return;
+                    }
+                    if (parsed.status === 'success') {
+                        resolve(parsed.data);
+                    }
+                    else {
+                        const detail = typeof parsed.data === 'string' ? parsed.data : JSON.stringify(parsed.data);
+                        reject(new Error(`playit API ${apiPath} failed: ${detail}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(payload);
+            req.end();
+        });
+    }
+    /** Returns agent run data: { agent_id, tunnels[], pending[] }. */
+    getRunData(secret) {
+        return this.apiPost('/agents/rundata', {}, secret);
+    }
+    /** Picks the public address from a rundata tunnel entry. */
+    tunnelAddress(tunnel) {
+        const port = tunnel?.port?.from ?? tunnel?.local_port ?? 0;
+        return { address: tunnel.assigned_domain, port: String(port) };
+    }
+    /** Finds an existing tunnel matching the requested protocol. */
+    findTunnel(rd, type) {
+        const proto = type === 'java' ? 'tcp' : 'udp';
+        const tunnels = (rd?.tunnels || []);
+        return tunnels.find((t) => t.proto === proto) || null;
+    }
+    /** Creates a new tunnel via the API (replaces the broken `tunnels prepare` CLI). */
+    async createApiTunnel(type, agentId, secret) {
+        const body = {
+            name: type === 'java' ? 'Minecraft Java' : 'Minecraft Bedrock',
+            tunnel_type: type === 'java' ? 'minecraft-java' : 'minecraft-bedrock',
+            port_type: type === 'java' ? 'tcp' : 'udp',
+            port_count: 1,
+            origin: {
+                type: 'agent',
+                data: {
+                    agent_id: agentId,
+                    local_ip: '127.0.0.1',
+                    local_port: type === 'java' ? 25565 : 19132,
+                },
+            },
+            enabled: true,
+            alloc: null,
+            firewall_id: null,
+            proxy_protocol: null,
+        };
+        await this.apiPost('/tunnels/create', body, secret);
+    }
+    sleep(ms) {
+        return new Promise((r) => setTimeout(r, ms));
+    }
+    // ---------------------------------------------------------------------------
+    // One-time claim flow (uses the control cli; persists the secret)
+    // ---------------------------------------------------------------------------
+    runCli(args, timeoutMs = 30000) {
+        const cliPath = this.getCliPath();
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)(cliPath, args, { cwd: path.dirname(cliPath), timeout: timeoutMs }, (error, stdout, stderr) => {
+                const out = stripAnsi(stdout || '').trim();
+                const err = stripAnsi(stderr || '').trim();
+                if (error) {
+                    reject(new Error(err || out || error.message));
+                    return;
+                }
+                resolve(out);
+            });
+        });
+    }
+    /** Ensures a write-capable agent secret, driving the one-time claim if needed. */
+    async ensureSecret(callbacks = {}) {
+        const existing = this.getSecret();
+        if (existing)
+            return existing;
+        await this.ensureBinary();
+        callbacks.onStatus?.('Generating a new agent claim code...');
+        const code = (await this.runCli(['claim', 'generate'])).replace(/[^a-f0-9]/gi, '');
+        if (!code)
+            throw new Error('Failed to generate a claim code.');
+        const url = (await this.runCli(['claim', 'url', code, '--name', 'mcpanel', '--type', 'self-managed'])).trim();
+        this.tunnelStatus.claimUrl = url;
+        callbacks.onClaimUrl?.(url);
+        callbacks.onStatus?.('Waiting for the agent to be claimed (this only happens once)...');
+        const secret = await this.exchangeClaim(code);
+        this.configManager.setPlayitSecret(secret);
+        this.tunnelStatus.claimUrl = null;
+        callbacks.onStatus?.('Agent claimed and linked. Secret saved — future tunnels are fully automatic.');
+        return secret;
+    }
+    /** Spawns `claim exchange` and resolves once a 64-char hex secret is printed. */
+    exchangeClaim(code) {
+        return new Promise((resolve, reject) => {
+            const cliPath = this.getCliPath();
+            const child = (0, child_process_1.spawn)(cliPath, ['claim', 'exchange', code, '--wait', '0'], {
+                cwd: path.dirname(cliPath),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            this.claimProcess = child;
+            let buffer = '';
+            const scan = (data) => {
+                buffer += stripAnsi(data.toString());
+                const match = buffer.match(/[a-f0-9]{64}/i);
+                if (match) {
+                    this.claimProcess = null;
+                    try {
+                        child.kill();
+                    }
+                    catch { /* ignore */ }
+                    resolve(match[0].toLowerCase());
+                }
+            };
+            child.stdout?.on('data', scan);
+            child.stderr?.on('data', scan);
+            child.on('close', (codeExit) => {
+                if (this.claimProcess === child) {
+                    this.claimProcess = null;
+                    const match = buffer.match(/[a-f0-9]{64}/i);
+                    if (match)
+                        resolve(match[0].toLowerCase());
+                    else
+                        reject(new Error(`Claim was not completed (exit ${codeExit}). Visit the link, then try again.`));
+                }
+            });
+            child.on('error', (err) => { this.claimProcess = null; reject(err); });
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Full automated setup
+    // ---------------------------------------------------------------------------
+    /**
+     * One-call entry point: ensures binary + secret, creates the tunnel via the
+     * API, starts the relay daemon, and returns the live tunnel status.
+     */
+    async setupAndStart(type, callbacks = {}) {
+        await this.ensureBinary();
+        const secret = await this.ensureSecret(callbacks);
+        this.tunnelStatus.status = 'Connecting';
+        this.tunnelStatus.type = type;
+        callbacks.onStatus?.('Checking your playit account for an existing tunnel...');
+        let rd = await this.getRunData(secret);
+        let tunnel = this.findTunnel(rd, type);
+        if (!tunnel) {
+            callbacks.onStatus?.(`Creating ${type} tunnel...`);
+            await this.createApiTunnel(type, rd.agent_id, secret);
+            // Poll until the tunnel leaves "pending" and gets a public address.
+            for (let i = 0; i < 15 && !tunnel; i++) {
+                await this.sleep(3000);
+                rd = await this.getRunData(secret);
+                tunnel = this.findTunnel(rd, type);
+            }
+            if (!tunnel) {
+                throw new Error('Tunnel was created but no public address appeared yet. Try /tunnel status shortly.');
+            }
+        }
+        const { address, port } = this.tunnelAddress(tunnel);
+        this.tunnelStatus.address = address;
+        this.tunnelStatus.port = port;
+        this.configManager.updatePlayitTunnel({ tunnelAddress: address, tunnelPort: Number(port) });
+        callbacks.onStatus?.('Starting tunnel relay...');
+        await this.startAgent(secret);
+        this.tunnelStatus.status = 'Online';
+        return this.tunnelStatus;
+    }
+    /** Spawns the long-running daemon that relays tunnel traffic. */
+    startAgent(secret) {
+        return new Promise((resolve) => {
+            if (this.playitProcess) {
+                resolve();
+                return;
+            }
+            const binPath = this.getExecutablePath();
+            const socketPath = this.getSocketPath();
+            // Clear any stale unix socket so the daemon can bind.
+            if ((0, helpers_1.detectOS)() !== 'Windows') {
+                try {
+                    if (fs.existsSync(socketPath))
+                        fs.unlinkSync(socketPath);
+                }
+                catch { /* ignore */ }
+            }
+            logger_1.logger.logTunnel('Starting playit relay daemon...');
+            this.playitProcess = (0, child_process_1.spawn)(binPath, ['--secret', secret, '--socket-path', socketPath], {
+                cwd: path.dirname(binPath),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            this.playitProcess.stdout?.on('data', (d) => {
+                const chunk = stripAnsi(d.toString());
+                logger_1.logger.logTunnel(`[stdout] ${chunk.trim()}`);
+                this.parsePlayitOutput(chunk);
+            });
+            this.playitProcess.stderr?.on('data', (d) => {
+                const chunk = stripAnsi(d.toString());
+                logger_1.logger.logTunnel(`[stderr] ${chunk.trim()}`);
+                this.parsePlayitOutput(chunk);
+            });
+            this.playitProcess.on('close', (code) => {
+                logger_1.logger.logTunnel(`Playit relay exited with code ${code}`);
+                this.playitProcess = null;
+                this.tunnelStatus = this.offlineStatus();
+            });
+            this.playitProcess.on('error', (err) => {
+                logger_1.logger.error('Playit relay process error', err);
+                this.tunnelStatus.status = 'Offline';
+            });
+            // Give the daemon a moment to register, then continue.
+            setTimeout(resolve, 2000);
+        });
+    }
+    stopTunnel() {
+        let stopped = false;
+        if (this.claimProcess) {
+            try {
+                this.claimProcess.kill('SIGINT');
+            }
+            catch { /* ignore */ }
+            this.claimProcess = null;
+            stopped = true;
+        }
+        if (this.playitProcess) {
+            logger_1.logger.logTunnel('Stopping playit relay daemon...');
+            try {
+                this.playitProcess.kill('SIGINT');
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to stop relay', err);
+            }
+            this.playitProcess = null;
+            stopped = true;
+        }
+        this.tunnelStatus = this.offlineStatus();
+        return stopped;
+    }
+    getStatus() {
+        return this.tunnelStatus;
+    }
+    /** Clears the saved secret so the agent can be re-claimed from scratch. */
+    async resetSecret() {
+        this.stopTunnel();
+        this.configManager.updatePlayitTunnel({ secret: undefined });
+        try {
+            await this.runCli(['reset']);
+        }
+        catch { /* local secret already cleared */ }
+    }
+    /** Parses relay logs to keep latency/status fresh. */
+    parsePlayitOutput(output) {
+        if (/agent registered|udp session details|tunnel running|tunnel active/i.test(output)) {
+            this.tunnelStatus.status = 'Online';
+        }
+        const pingMatch = output.match(/ping:\s*(\d+\.?\d*ms)/i) || output.match(/latency:\s*(\d+\.?\d*ms)/i);
+        if (pingMatch)
+            this.tunnelStatus.latency = pingMatch[1];
+    }
+}
+exports.PlayitManager = PlayitManager;