@danieltmn/openbridge 0.1.0

package/src/store/jsonfile.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Lectura/escritura de JSON con serializacion por archivo.
+ *
+ * El server Node es el unico escritor de `data/` (el puente habla por HTTP, no
+ * toca los archivos), asi que un mutex en memoria alcanza. La escritura va a un
+ * .tmp y rename() para que los lectores nunca vean un archivo a medio escribir.
+ */
+
+const fs = require('node:fs/promises');
+
+const locks = new Map();
+
+function withLock(key, fn) {
+    const prev = locks.get(key) || Promise.resolve();
+    const run = prev.then(fn, fn);
+    // La cadena no debe romperse por un error de un eslabon.
+    locks.set(key, run.then(() => {}, () => {}));
+    return run;
+}
+
+async function readJson(file, fallback) {
+    try {
+        const raw = await fs.readFile(file, 'utf8');
+        const data = JSON.parse(raw);
+        return (data && typeof data === 'object') ? data : structuredClone(fallback);
+    } catch (e) {
+        return structuredClone(fallback);
+    }
+}
+
+async function writeAtomic(file, data) {
+    const tmp = file + '.' + process.pid + '.' + Math.random().toString(36).slice(2) + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2));
+    await fs.rename(tmp, file);
+}
+
+/**
+ * Lee, deja modificar con fn(data) y guarda. Si fn devuelve false, no guarda.
+ * Si fn devuelve un objeto, ese objeto reemplaza al leido.
+ */
+async function update(file, fallback, fn) {
+    return withLock(file, async () => {
+        let data = await readJson(file, fallback);
+        const res = await fn(data);
+        if (res === false) return false;
+        if (res && typeof res === 'object') data = res;
+        await writeAtomic(file, data);
+        return data;
+    });
+}
+
+module.exports = { withLock, readJson, writeAtomic, update };

package/src/tunnel/index.js

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Tuneles publicos. Proveedores soportados:
+ *   - tunnelmole  (gratis, sin cuenta; URL aleatoria)   -> `npx tunnelmole <puerto>`
+ *   - ngrok       (requiere cuenta + authtoken; admite dominio fijo) -> `ngrok http`
+ *   - cloudflare  (gratis, quick tunnel; URL aleatoria) -> `cloudflared tunnel --url`
+ *
+ * La interfaz es generica: startTunnel(port, provider, opts) -> { url, provider, pid, stop }.
+ */
+
+const { spawn } = require('node:child_process');
+
+function firstUrl(urls, scheme) {
+    const list = [...new Set(urls)];
+    return list.find((u) => u.startsWith(scheme)) || '';
+}
+
+function parseTunnelmoleUrls(text) {
+    const urls = String(text).match(/https?:\/\/[a-z0-9-]+\.tunnelmole\.net/gi) || [];
+    return { https: firstUrl(urls, 'https'), http: firstUrl(urls, 'http:') };
+}
+
+function parseNgrokUrls(text) {
+    const urls = String(text).match(/https?:\/\/[a-z0-9-]+\.ngrok(?:-free)?\.(?:app|io|dev)/gi) || [];
+    return { https: firstUrl(urls, 'https'), http: firstUrl(urls, 'http:') };
+}
+
+function parseCloudflaredUrls(text) {
+    const urls = String(text).match(/https?:\/\/[a-z0-9-]+\.trycloudflare\.com/gi) || [];
+    return { https: firstUrl(urls, 'https'), http: firstUrl(urls, 'http:') };
+}
+
+function killTree(child) {
+    if (!child || child.killed) return;
+    const pid = child.pid;
+    try {
+        if (process.platform === 'win32' && pid) {
+            spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+        } else {
+            if (pid) { try { process.kill(-pid, 'SIGTERM'); } catch (e) { /* sin grupo */ } }
+            try { child.kill('SIGTERM'); } catch (e) { /* ya murio */ }
+        }
+    } catch (e) { /* ya murio */ }
+}
+
+// Lanza un binario y resuelve cuando el parseador encuentra una URL.
+function spawnTunnel(bin, args, opts = {}) {
+    const log = opts.log || (() => {});
+    const parse = opts.parse || (() => ({ https: '', http: '' }));
+    const timeoutMs = opts.timeoutMs || 90000;
+    const label = opts.label || bin;
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(bin, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+                shell: process.platform === 'win32',
+                detached: process.platform !== 'win32',
+            });
+        } catch (e) {
+            reject(new Error('no se pudo iniciar ' + label + ': ' + e.message));
+            return;
+        }
+        let buf = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            killTree(child);
+            reject(new Error(label + ' no devolvio URL (' + Math.round(timeoutMs / 1000) + ' s). Instalalo o proba otro proveedor.'));
+        }, timeoutMs);
+        const feed = (d) => {
+            buf += String(d);
+            if (opts.verbose) process.stdout.write(String(d));
+            const urls = parse(buf);
+            if (urls.https || urls.http) {
+                if (settled) return;
+                settled = true;
+                clearTimeout(timer);
+                const url = urls.https || urls.http;
+                log(label + ': ' + url + ' -> localhost:' + opts.port);
+                resolve({ url, provider: opts.provider, pid: child.pid, stop: () => killTree(child) });
+            }
+        };
+        child.stdout.on('data', feed);
+        child.stderr.on('data', feed);
+        child.on('error', (e) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new Error(label + ': ' + e.message));
+        });
+        child.on('exit', (code) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new Error(label + ' termino (codigo ' + code + ')' + (buf ? ': ' + buf.slice(0, 200).trim() : '')));
+        });
+    });
+}
+
+function startTunnelmole(port, opts = {}) {
+    return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
+        ...opts, port, provider: 'tunnelmole', label: 'tunnelmole', parse: parseTunnelmoleUrls,
+    });
+}
+
+function startNgrok(port, opts = {}) {
+    const args = ['http', String(port), '--log', 'stdout', '--log-format', 'json'];
+    if (opts.domain) args.push('--domain=' + opts.domain);
+    return spawnTunnel('ngrok', args, {
+        ...opts, port, provider: 'ngrok', label: 'ngrok', parse: parseNgrokUrls,
+    });
+}
+
+function startCloudflared(port, opts = {}) {
+    const args = ['tunnel', '--no-autoupdate', '--url', 'http://127.0.0.1:' + port];
+    return spawnTunnel('cloudflared', args, {
+        ...opts, port, provider: 'cloudflare', label: 'cloudflared', parse: parseCloudflaredUrls,
+    });
+}
+
+/**
+ * Arranca el tunel segun el proveedor. Devuelve { url, provider, pid, stop }.
+ * provider 'none' no abre nada.
+ */
+async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
+    const p = String(provider || 'tunnelmole').toLowerCase();
+    if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
+    if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
+    if (p === 'ngrok') return startNgrok(port, opts);
+    if (p === 'cloudflare' || p === 'cloudflared') return startCloudflared(port, opts);
+    throw new Error('proveedor de tunel no soportado: ' + provider);
+}
+
+module.exports = {
+    startTunnel, startTunnelmole, startNgrok, startCloudflared,
+    parseTunnelmoleUrls, parseNgrokUrls, parseCloudflaredUrls,
+};