@danieltmn/openbridge 0.1.0

package/src/config.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const fs = require('node:fs');
+const crypto = require('node:crypto');
+const paths = require('./paths');
+
+const DEFAULT_BRIDGE = {
+    apiUrl: '',
+    apiUrlLocal: '',
+    mode: 'remoto',
+    apiToken: '',
+    pollIntervalMs: 1500,
+    command: 'opencode',
+    opencodeTimeoutMs: 15 * 60 * 1000,
+    logFile: 'logs/bridge.log',
+    foldersFile: 'folders.json',
+    workspace: '',
+    allowCreateFolders: true,
+    models: [],
+    agents: ['build', 'plan'],
+    bridgeId: '',
+    bridgeName: '',
+    processes: { enabled: true, allow: ['npm', 'node', 'npx'], maxGlobal: 3 },
+};
+
+const DEFAULT_APP = {
+    port: 8799,
+    host: '127.0.0.1',
+    baseUrl: '',
+    username: 'admin',
+    password: null,          // { algo, salt, hash, keylen }
+    csrfSecret: '',
+    bridgeToken: '',
+    vapid: { publicKey: '', privateKey: '' },
+    tunnel: { provider: 'tunnelmole', domain: '' },
+};
+
+function readJsonFile(file, fallback) {
+    try {
+        const raw = fs.readFileSync(file, 'utf8');
+        const data = JSON.parse(raw);
+        return (data && typeof data === 'object') ? data : { ...fallback };
+    } catch (e) {
+        return { ...fallback };
+    }
+}
+
+function writeJsonFile(file, data) {
+    paths.ensureDirs();
+    const tmp = file + '.' + process.pid + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+    fs.renameSync(tmp, file);
+}
+
+function readBridge() {
+    return { ...DEFAULT_BRIDGE, ...readJsonFile(paths.configPath(), DEFAULT_BRIDGE) };
+}
+function writeBridge(cfg) {
+    writeJsonFile(paths.configPath(), cfg);
+}
+function readApp() {
+    const data = { ...DEFAULT_APP, ...readJsonFile(paths.appConfigPath(), DEFAULT_APP) };
+    data.vapid = { ...DEFAULT_APP.vapid, ...(data.vapid || {}) };
+    data.tunnel = { ...DEFAULT_APP.tunnel, ...(data.tunnel || {}) };
+    return data;
+}
+function writeApp(cfg) {
+    writeJsonFile(paths.appConfigPath(), cfg);
+}
+
+function randomToken(bytes = 32) {
+    return crypto.randomBytes(bytes).toString('base64url');
+}
+
+function hashPassword(password) {
+    const salt = crypto.randomBytes(16).toString('hex');
+    const keylen = 64;
+    const hash = crypto.scryptSync(String(password), salt, keylen).toString('hex');
+    return { algo: 'scrypt', salt, hash, keylen };
+}
+
+function verifyPassword(password, stored) {
+    if (!stored || stored.algo !== 'scrypt' || !stored.salt || !stored.hash) return false;
+    const keylen = parseInt(stored.keylen, 10) || 64;
+    let calc;
+    try {
+        calc = crypto.scryptSync(String(password), stored.salt, keylen);
+    } catch (e) {
+        return false;
+    }
+    const expected = Buffer.from(stored.hash, 'hex');
+    if (calc.length !== expected.length) return false;
+    return crypto.timingSafeEqual(calc, expected);
+}
+
+// Claves VAPID (P-256) en el formato que espera web-push (base64url).
+function genVapid() {
+    const webpush = require('web-push');
+    const keys = webpush.generateVAPIDKeys();
+    return { publicKey: keys.publicKey, privateKey: keys.privateKey };
+}
+
+module.exports = {
+    DEFAULT_BRIDGE, DEFAULT_APP,
+    readBridge, writeBridge, readApp, writeApp,
+    randomToken, hashPassword, verifyPassword, genVapid,
+    readJsonFile, writeJsonFile,
+};

package/src/log.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const fs = require('node:fs');
+const paths = require('./paths');
+
+function ts() {
+    return new Date().toISOString();
+}
+
+function write(line) {
+    const text = '[' + ts() + '] ' + line;
+    try {
+        fs.appendFileSync(paths.serverLogPath(), text + '\n');
+    } catch (e) { /* sin log no detenemos nada */ }
+    console.log(text);
+}
+
+function log(...parts) { write(parts.join(' ')); }
+function error(...parts) { write('ERROR: ' + parts.join(' ')); }
+function warn(...parts) { write('aviso: ' + parts.join(' ')); }
+
+module.exports = { log, error, warn };

package/src/paths.js

@@ -0,0 +1,152 @@
+'use strict';
+
+/**
+ * Casa portable de OpenBridge.
+ *
+ * La "base" es el directorio que elegis (cwd, --dir o OPENBRIDGE_HOME). Todos
+ * los archivos de OpenBridge viven dentro de `<base>/.openbridge`:
+ *
+ *   config.json   → configuracion del puente (la lee src/bridge/bridge.js)
+ *   app.json      → configuracion de la app (password, token, VAPID, puerto)
+ *   folders.json  → lista blanca de carpetas
+ *   data/         → sesiones, mensajes, catalogos, registro de puentes, push
+ *   logs/         → logs del server y del puente
+ *
+ * Si existe un layout viejo (config.json suelto en la base), migrate() lo mueve
+ * automaticamente a `.openbridge/`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DIR_NAME = '.openbridge';
+
+let overrideBase = null;
+
+function setBase(dir) {
+    overrideBase = dir ? path.resolve(dir) : null;
+}
+// Alias historico: la CLI y los tests llaman setHome(dir) con la base.
+function setHome(dir) { setBase(dir); }
+
+function baseDir() {
+    if (overrideBase) return overrideBase;
+    const env = process.env.OPENBRIDGE_HOME || process.env.OPENCONEX_HOME;
+    if (env) return path.resolve(env);
+    return process.cwd();
+}
+
+function home() {
+    const base = baseDir();
+    // Evita anidar `.openbridge/.openbridge` si la base ya ES la carpeta de datos.
+    if (path.basename(base) === DIR_NAME) return base;
+    return path.join(base, DIR_NAME);
+}
+
+function p(...parts) {
+    return path.join(home(), ...parts);
+}
+
+function configPath() { return p('config.json'); }
+function appConfigPath() { return p('app.json'); }
+function foldersPath() { return p('folders.json'); }
+function modePath() { return p('mode.txt'); }
+function pidPath() { return p('.openbridge.pid'); }
+function bridgeLockPath() { return p('.bridge.pid'); }
+function dataDir() { return p('data'); }
+function logsDir() { return p('logs'); }
+function serverLogPath() { return p('logs', 'server.log'); }
+function bridgeLogPath() { return p('logs', 'bridge.log'); }
+function syncStatePath() { return p('sync-state.json'); }
+function procsStatePath() { return p('.procs.json'); }
+
+function sessionsFile() { return p('data', 'sessions.json'); }
+function catalogFile() { return p('data', 'catalog.json'); }
+function bridgesFile() { return p('data', 'bridges.json'); }
+function pushFile() { return p('data', 'push.json'); }
+function messagesFile(id) { return p('data', 'messages-' + (parseInt(id, 10) || 0) + '.json'); }
+function bridgeCatalogFile(id) {
+    if (!id || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,39}$/.test(id)) return catalogFile();
+    return p('data', 'catalog-' + id.replace(/[^A-Za-z0-9._-]/g, '') + '.json');
+}
+
+// ---------------------------------------------------------------------------
+// Migracion del layout viejo (archivos sueltos en la base) a `.openbridge/`
+// ---------------------------------------------------------------------------
+const LEGACY_FILES = [
+    'config.json', 'app.json', 'folders.json', 'mode.txt',
+    'sync-state.json', '.procs.json', '.openbridge.pid', '.bridge.pid', 'runtime.json',
+];
+
+function legacyDataDir(dir) {
+    return fs.existsSync(path.join(dir, 'sessions.json'))
+        || fs.existsSync(path.join(dir, 'catalog.json'))
+        || fs.existsSync(path.join(dir, 'bridges.json'));
+}
+function legacyLogsDir(dir) {
+    return fs.existsSync(path.join(dir, 'bridge.log'))
+        || fs.existsSync(path.join(dir, 'server.log'));
+}
+
+function movePath(from, to) {
+    try {
+        fs.renameSync(from, to);
+        return true;
+    } catch (e) {
+        try {
+            fs.cpSync(from, to, { recursive: true });
+            fs.rmSync(from, { recursive: true, force: true });
+            return true;
+        } catch (e2) {
+            return false;
+        }
+    }
+}
+
+// Mueve el layout viejo a `.openbridge/`. Devuelve los nombres migrados (array;
+// vacio si no habia nada que migrar). Solo toca data/ y logs/ si tienen marcas
+// de OpenBridge, para no mover carpetas ajenas del usuario.
+function migrate() {
+    const base = baseDir();
+    const target = home();
+    if (fs.existsSync(target)) return [];
+    if (!fs.existsSync(path.join(base, 'config.json'))) return [];
+
+    const items = [];
+    for (const n of LEGACY_FILES) {
+        if (fs.existsSync(path.join(base, n))) items.push(n);
+    }
+    const dataSrc = path.join(base, 'data');
+    if (fs.existsSync(dataSrc) && legacyDataDir(dataSrc)) items.push('data');
+    const logsSrc = path.join(base, 'logs');
+    if (fs.existsSync(logsSrc) && legacyLogsDir(logsSrc)) items.push('logs');
+    if (!items.length) return [];
+
+    try { fs.mkdirSync(target, { recursive: true }); } catch (e) { return []; }
+    const moved = [];
+    for (const n of items) {
+        if (movePath(path.join(base, n), path.join(target, n))) moved.push(n);
+    }
+    return moved;
+}
+
+function ensureDirs() {
+    migrate();
+    for (const d of [home(), dataDir(), logsDir()]) {
+        try { fs.mkdirSync(d, { recursive: true }); } catch (e) { /* ya existe */ }
+    }
+}
+
+function exists() {
+    return fs.existsSync(configPath()) && fs.existsSync(appConfigPath());
+}
+
+module.exports = {
+    DIR_NAME,
+    setBase, setHome, baseDir, home, p,
+    configPath, appConfigPath, foldersPath, modePath, pidPath, bridgeLockPath,
+    dataDir, logsDir, serverLogPath, bridgeLogPath,
+    syncStatePath, procsStatePath,
+    sessionsFile, catalogFile, bridgesFile, pushFile, messagesFile, bridgeCatalogFile,
+    migrate, ensureDirs, exists,
+};

package/src/push.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Avisos Web Push (VAPID + cifrado RFC 8291/8188). Usa la libreria `web-push`
+ * para el envio; las suscripciones viven en data/push.json (mismo esquema que
+ * la version PHP: endpoint + p256dh + auth).
+ */
+
+const paths = require('./paths');
+const jsonfile = require('./store/jsonfile');
+
+const PUSH_DEFAULT = () => ({ subscriptions: [] });
+
+function pushEnabled(app) {
+    return !!(app && app.vapid && app.vapid.publicKey && app.vapid.privateKey);
+}
+function publicKeyBase64url(app) {
+    return pushEnabled(app) ? app.vapid.publicKey : '';
+}
+
+async function pushRead() {
+    const data = await jsonfile.readJson(paths.pushFile(), PUSH_DEFAULT());
+    if (!Array.isArray(data.subscriptions)) data.subscriptions = [];
+    return data;
+}
+async function pushStore(endpoint, p256dh, auth, ua = '') {
+    await jsonfile.update(paths.pushFile(), PUSH_DEFAULT(), (data) => {
+        if (!Array.isArray(data.subscriptions)) data.subscriptions = [];
+        const found = data.subscriptions.find((s) => s.endpoint === endpoint);
+        if (found) {
+            found.p256dh = p256dh;
+            found.auth = auth;
+            found.ua = ua;
+            found.ts = new Date().toISOString();
+        } else {
+            data.subscriptions.push({ endpoint, p256dh, auth, ua, ts: new Date().toISOString() });
+        }
+    });
+}
+async function pushRemove(endpoint) {
+    await jsonfile.update(paths.pushFile(), PUSH_DEFAULT(), (data) => {
+        data.subscriptions = (data.subscriptions || []).filter((s) => s.endpoint !== endpoint);
+    });
+}
+
+// Envia el aviso a todas las suscripciones. Devuelve cuantas se pudieron enviar.
+async function pushSend(app, title, body, clickPath = 'chat.php') {
+    if (!pushEnabled(app)) return 0;
+    let webpush;
+    try { webpush = require('web-push'); } catch (e) { return 0; }
+    const url = (app.baseUrl || 'http://localhost') + '/' + String(clickPath || 'chat.php');
+    const payload = JSON.stringify({ title, body, url, ts: new Date().toISOString() });
+    if (Buffer.byteLength(payload) > 3500) return 0;
+    try {
+        webpush.setVapidDetails(app.baseUrl || 'http://localhost', app.vapid.publicKey, app.vapid.privateKey);
+    } catch (e) {
+        return 0;
+    }
+    const data = await pushRead();
+    let sent = 0;
+    const dead = [];
+    for (const sub of data.subscriptions) {
+        const endpoint = sub.endpoint || '';
+        if (!/^https:\/\//.test(endpoint)) continue;
+        try {
+            await webpush.sendNotification(
+                { endpoint, keys: { p256dh: sub.p256dh, auth: sub.auth } },
+                payload,
+                { TTL: 86400 }
+            );
+            sent++;
+        } catch (e) {
+            const code = e && e.statusCode;
+            if (code === 404 || code === 410) dead.push(endpoint);
+        }
+    }
+    if (dead.length) {
+        await jsonfile.update(paths.pushFile(), PUSH_DEFAULT(), (d) => {
+            d.subscriptions = (d.subscriptions || []).filter((s) => !dead.includes(s.endpoint));
+        });
+    }
+    return sent;
+}
+
+module.exports = { pushEnabled, publicKeyBase64url, pushRead, pushStore, pushRemove, pushSend };