@danieltmn/openbridge 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -4,6 +4,23 @@ Todos los cambios relevantes de OpenBridge. Formato basado en
 [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/) y
 [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.5.2] - 2026-09-14
+
+### Corregido
+
+- Diagnostico de puerto ocupado: `status` y `server` muestran que **PID** usa el
+  puerto (suele ser otra casa con otro `--dir`) y, si el arranque en segundo plano
+  muere, se muestran las ultimas lineas de `server.log`.
+- `store`: reintentos con backoff en el `rename` atomico (EPERM/EACCES/EBUSY en
+  Windows) y limpieza del `.tmp` si no se puede.
+
+## [0.5.1] - 2026-09-14
+
+### Corregido
+
+- `openbridge join` normaliza la URL del hub a `/api.php` (antes, pasar la base
+  o `/chat.php` apuntaba a `/` y el puente se quedaba sin trabajo).
+
 ## [0.5.0] - 2026-09-14
 
 ### Agregado

package/README.md

@@ -133,7 +133,8 @@ Ejemplo concreto:
 3. En la **PC 2** (remota):
    ```bash
    openbridge join https://tu-url-publica --token <bridgeToken> --id pc2 --name "PC 2"
-   # guarda la config y arranca el puente; con --no-start solo guarda
+   # acepta la base, /chat.php o /api.php; se normaliza a /api.php
+   # con --no-start solo guarda la config
    ```
    (equivale a `openbridge bridge --api … --token … --id … --name …`, pero
    persiste la config para no repetir flags)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/openbridge",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Tu opencode en el celular, sin hosting: corre la app, el puente y un tunel publico desde tu PC.",
   "type": "commonjs",
   "author": "tamnora",

package/src/cli.js

@@ -105,6 +105,70 @@ function pidAlive(pid) {
     try { process.kill(pid, 0); return true; } catch (e) { return false; }
 }
 
+// PIDs escuchando en un puerto TCP (netstat en Windows; lsof en el resto). Sirve
+// para explicar un EADDRINUSE: normalmente es OTRA casa (otro --dir) con el
+// mismo puerto por defecto.
+function portOwnerPids(port) {
+    try {
+        const win = process.platform === 'win32';
+        const r = spawnSync(win ? 'netstat' : 'lsof',
+            win ? ['-ano', '-p', 'tcp'] : ['-t', '-i', 'tcp:' + port, '-s', 'tcp:listen'],
+            { encoding: 'utf8', windowsHide: true, timeout: 15000 });
+        if (r.error || !r.stdout) return [];
+        const pids = new Set();
+        if (!win) {
+            for (const n of String(r.stdout).split(/\s+/)) {
+                const p = parseInt(n, 10);
+                if (p > 0) pids.add(p);
+            }
+            return [...pids];
+        }
+        const re = new RegExp(':' + port + '\\s');
+        for (const line of String(r.stdout).split(/\r?\n/)) {
+            if (!re.test(line) || !/LISTENING/i.test(line)) continue;
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[parts.length - 1], 10);
+            if (pid > 0) pids.add(pid);
+        }
+        return [...pids];
+    } catch (e) {
+        return [];
+    }
+}
+
+// Nombre del proceso de un PID (best-effort) para el diagnostico del puerto.
+function describePid(pid) {
+    try {
+        if (process.platform === 'win32') {
+            const r = spawnSync('tasklist', ['/FI', 'PID eq ' + pid, '/FO', 'CSV', '/NH'], { encoding: 'utf8', windowsHide: true, timeout: 8000 });
+            const m = String(r.stdout || '').match(/^"([^"]+)"/m);
+            return m ? m[1] : '';
+        }
+        const r = spawnSync('ps', ['-p', String(pid), '-o', 'comm='], { encoding: 'utf8', windowsHide: true, timeout: 8000 });
+        return String(r.stdout || '').trim();
+    } catch (e) {
+        return '';
+    }
+}
+
+// "PID 123 (node.exe)" para el proceso que ocupa el puerto, o '' si no hay.
+function portHint(port) {
+    const pids = portOwnerPids(port);
+    if (!pids.length) return '';
+    return pids.map((p) => 'PID ' + p + (describePid(p) ? ' (' + describePid(p) + ')' : '')).join(', ');
+}
+
+// Ultimas `n` lineas no vacias de un archivo (para mostrar el error real del
+// server cuando arranca en segundo plano y muere).
+function tailLines(file, n) {
+    try {
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/).filter((l) => l.trim() !== '');
+        return lines.slice(-n).join('\n');
+    } catch (e) {
+        return '';
+    }
+}
+
 function runtimePath() { return paths.p('runtime.json'); }
 function readRuntime() {
     try { return JSON.parse(fs.readFileSync(runtimePath(), 'utf8')); } catch (e) { return null; }
@@ -328,6 +392,12 @@ async function cmdServer(argv) {
         await printStatus();
         if (!rt) {
             console.log('');
+            const tail = tailLines(paths.serverLogPath(), 8);
+            if (tail) {
+                console.log('Ultimas lineas de ' + paths.serverLogPath() + ':');
+                console.log(tail);
+                console.log('');
+            }
             console.log('No pude confirmar el arranque. Revisa: openbridge logs');
         }
         return 0;
@@ -349,6 +419,12 @@ async function cmdServer(argv) {
     } catch (e) {
         if (e && e.code === 'EADDRINUSE') {
             log.error('puerto ' + port + ' ocupado (¿ya corre OpenBridge?). Usa --port <otro> o `openbridge stop`.');
+            const hint = portHint(port);
+            if (hint) {
+                console.error('  lo esta usando: ' + hint);
+                console.error('  puede ser otra casa (otro --dir): proba `openbridge stop --dir <esa-casa>`'
+                    + (process.platform === 'win32' ? ' o `taskkill /PID ' + portOwnerPids(port)[0] + ' /T /F`.' : '.'));
+            }
             return 1;
         }
         throw e;
@@ -443,6 +519,14 @@ async function printStatus() {
         if (paths.exists()) {
             console.log('  carpeta: ' + paths.baseDir());
             console.log('  datos  : ' + paths.home());
+            try {
+                const app = config.readApp();
+                const hint = portHint(app.port);
+                if (hint) {
+                    console.log('  aviso  : el puerto ' + app.port + ' ya lo usa ' + hint);
+                    console.log('           suele ser otra casa (otro --dir); cerrala con `openbridge stop --dir <esa-casa>` o usa --port <otro>.');
+                }
+            } catch (e) { /* sin app.json no hay puerto que mirar */ }
         }
         return false;
     }
@@ -624,17 +708,28 @@ async function cmdBridge(argv) {
 // join: esta PC se suma como puente de un hub (otra PC con `openbridge server`).
 // Guarda la URL/token/identidad en config.json y arranca el puente.
 // ---------------------------------------------------------------------------
+// Normaliza la URL del hub a su endpoint de API: acepta la base, /chat.php o
+// /api.php y devuelve siempre algo terminado en /api.php (lo que espera el
+// puente). Sin esto, un `join https://host` apuntaba a / y no al API.
+function hubApiUrl(raw) {
+    let u = String(raw || '').trim().replace(/\/+$/, '');
+    u = u.replace(/\/chat\.php$/i, '');
+    if (!/\/api\.php$/i.test(u)) u += '/api.php';
+    return u;
+}
+
 async function cmdJoin(argv) {
     const { flags, _ } = parseArgs(argv);
     const url = String(_[0] || flags.api || '').trim();
     if (!url || !/^https?:\/\//i.test(url)) {
         console.error('Uso: openbridge join <url-del-hub> [--token <t>] [--id <pc>] [--name "<nombre>"] [--no-start]');
         console.error('Ej.:  openbridge join https://mi-pc.trycloudflare.com --token <t> --id pc2 --name "PC oficina"');
+        console.error('(acepta la base, /chat.php o /api.php; se normaliza a /api.php)');
         return 1;
     }
     paths.ensureDirs();
     const cfg = config.readBridge();
-    cfg.apiUrl = url.replace(/\/+$/, '');
+    cfg.apiUrl = hubApiUrl(url);
     if (typeof flags.token === 'string') cfg.apiToken = flags.token;
     if (typeof flags.id === 'string') cfg.bridgeId = sanitizeId(flags.id);
     else if (!cfg.bridgeId) cfg.bridgeId = sanitizeId(os.hostname());

package/src/store/jsonfile.js

@@ -12,6 +12,29 @@ const fs = require('node:fs/promises');
 
 const locks = new Map();
 
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// En Windows, rename() puede fallar con EPERM/EACCES si otro proceso (antivirus,
+// indexador) tiene el archivo abierto un instante. Reintentamos con backoff y,
+// si no hay forma, limpiamos el .tmp.
+async function renameWithRetry(from, to, tries = 5) {
+    for (let i = 0; ; i++) {
+        try {
+            await fs.rename(from, to);
+            return;
+        } catch (e) {
+            const transient = e && (e.code === 'EPERM' || e.code === 'EACCES' || e.code === 'EBUSY');
+            if (!transient || i >= tries - 1) {
+                try { await fs.unlink(from); } catch (e2) { /* nada */ }
+                throw e;
+            }
+            await delay(20 * (i + 1));
+        }
+    }
+}
+
 function withLock(key, fn) {
     const prev = locks.get(key) || Promise.resolve();
     const run = prev.then(fn, fn);
@@ -33,7 +56,7 @@ async function readJson(file, 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);
+    await renameWithRetry(tmp, file);
 }
 
 /**