Spaces:
Running
Running
File size: 9,853 Bytes
b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 4bd8362 b30b7c5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | // Cliente del Elffuss Bridge: puente local (proceso que el usuario descarga y
// ejecuta) que da ejecución REAL en su máquina (node, npm, python…) sin salir
// de ella. Protocolo por WebSocket a 127.0.0.1, con token de un solo arranque.
const PORT = 8765;
const HOST = '127.0.0.1:' + PORT;
let ws = null, connected = false, authed = false;
let pending = new Map(); // id → { onOut, onErr, sock, terminar }
let nextId = 1;
// Varios pueden querer saber si el bridge conecta o cae (Ajustes, la etiqueta
// del terminal…). Antes había UN solo oyente y cada uno pisaba al anterior.
const oyentes = new Set();
const onStatus = (s) => { for (const f of oyentes) { try { f(s); } catch { /* */ } } };
// «Desconectar» a propósito: la autodetección no vuelve a conectar sola hasta
// que se pulse «Conectar» otra vez (antes reconectaba a los pocos segundos).
// Se GUARDA: solo en memoria, al recargar tryAutoConnect() volvía a conectar con
// el token guardado, y el aviso decía «no se volverá a conectar solo hasta que
// pulses Conectar».
const CLAVE_PAUSA = 'elffusscode.bridgePaused';
let pausado = false;
try { pausado = localStorage.getItem(CLAVE_PAUSA) === '1'; } catch { /* */ }
const guardaPausa = v => { try { if (v) localStorage.setItem(CLAVE_PAUSA, '1'); else localStorage.removeItem(CLAVE_PAUSA); } catch { /* */ } };
let savedFolder = '';
try { savedFolder = localStorage.getItem('elffusscode.bridgeFolder') || ''; } catch { /* */ }
let savedToken = '';
try { savedToken = localStorage.getItem('elffusscode.bridgeToken') || ''; } catch { /* */ }
export function isConnected() { return connected && authed; }
// La versión que se descarga desde esta web (web/bridge-dl). Desde la 1.1.2,
// parar un comando mata también lo que ese comando arrancó (un «npm run dev»,
// un servidor, «a; b») y cerrar la conexión mata lo que quedara corriendo. Con
// una anterior el agente y el terminal lo dan por parado, pero el proceso sigue
// vivo en la máquina: hay que decirle al usuario que la actualice. El bridge
// dice su versión en /ping desde siempre; antes nadie la miraba.
export const VERSION_ACTUAL = '1.1.2';
let versionVista = null;
export function version() { return versionVista; }
const partesVersion = v => String(v).split('.').map(n => parseInt(n, 10) || 0);
export function esViejo() {
if (!versionVista) return false;
const [a, b] = [partesVersion(versionVista), partesVersion(VERSION_ACTUAL)];
for (let i = 0; i < 3; i++) if ((a[i] || 0) !== (b[i] || 0)) return (a[i] || 0) < (b[i] || 0);
return false;
}
export function getFolder() { return savedFolder; }
export function setFolder(f) {
savedFolder = (f || '').trim();
try { localStorage.setItem('elffusscode.bridgeFolder', savedFolder); } catch { /* */ }
}
// Devuelve la función para dejar de escuchar.
export function onStatusChange(fn) { oyentes.add(fn); return () => oyentes.delete(fn); }
// sondeo ligero: ¿hay un bridge escuchando en 127.0.0.1, aunque no nos hayamos
// autenticado todavía? (para saber si mostrar «detectado» antes de conectar)
export async function probe() {
try {
const r = await fetch('http://' + HOST + '/ping', { mode: 'cors' });
if (!r.ok) return false;
const j = await r.json();
if (j.version) versionVista = String(j.version);
return !!j.ok;
} catch { return false; }
}
export function connect(token) {
pausado = false; guardaPausa(false);
return new Promise((resolve, reject) => {
let sock;
try { sock = ws = new WebSocket('ws://' + HOST + '/ws'); }
catch (e) { reject(e); return; }
const timeout = setTimeout(() => { try { sock.close(); } catch { /* */ } reject(new Error('tiempo agotado — ¿está el bridge arrancado?')); }, 6000);
sock.onopen = () => sock.send(JSON.stringify({ type: 'auth', token }));
sock.onerror = () => { clearTimeout(timeout); connected = false; authed = false; onStatus('error'); reject(new Error('no pude conectar — ¿está el bridge arrancado en este puerto? Si lo descargaste antes de la versión 1.1.1, descárgalo otra vez: los anteriores no aceptan la dirección nueva de Elffuss Code.')); };
sock.onclose = () => {
// Lo que corría por ESTE socket ya no va a recibir nunca su «exit»: se
// cierra aquí. Antes quedaba pendiente para siempre, y con él el turno del
// agente o el terminal que lo esperaba.
cerrarTrabajos(sock);
if (ws !== sock) return; // un socket viejo que se cierra no desconecta al nuevo
connected = false; authed = false; onStatus('disconnected');
};
sock.onmessage = e => {
let m; try { m = JSON.parse(e.data); } catch { return; }
if (m.type === 'auth-ok') {
clearTimeout(timeout);
connected = true; authed = true;
savedToken = token;
try { localStorage.setItem('elffusscode.bridgeToken', token); } catch { /* */ }
onStatus('connected');
resolve(true);
// Qué versión es (para avisar si es vieja): se avisa otra vez al saberlo.
probe().then(() => { if (ws === sock && isConnected()) onStatus('version'); }).catch(() => {});
return;
}
if (m.type === 'auth-fail') { clearTimeout(timeout); connected = true; authed = false; onStatus('auth-fail'); reject(new Error('token incorrecto')); return; }
const job = pending.get(m.id);
if (!job) return; // p. ej. la salida tardía de un comando ya parado
if (m.type === 'stdout') job.onOut(m.data);
else if (m.type === 'stderr') job.onErr(m.data);
else if (m.type === 'error') { job.onErr(m.data); job.terminar(-1); }
else if (m.type === 'exit') job.terminar(m.code || 0);
};
});
}
export function disconnect() {
pausado = true; guardaPausa(true);
try { ws?.close(); } catch { /* */ }
connected = false; authed = false;
onStatus('disconnected');
}
// Olvidar el token guardado: desconecta y ya no se reconecta solo.
export function forgetToken() {
savedToken = '';
try { localStorage.removeItem('elffusscode.bridgeToken'); } catch { /* */ }
disconnect();
}
export function hasSavedToken() { return !!savedToken; }
// Lo que conecta SOLO (al abrir, o al detectar el bridge) no lo hace si el
// usuario desconectó a propósito; connect() a secas es el botón «Conectar».
function connectAuto(token) { return pausado ? Promise.reject(new Error('pausado')) : connect(token); }
// tratar de reconectar en silencio con el token guardado (al abrir la app)
export async function tryAutoConnect() {
if (!savedToken || pausado) return false;
try { await connectAuto(savedToken); return true; } catch { return false; }
}
// Detección continua en segundo plano: si el usuario arranca el bridge
// DESPUÉS de cargar la página (o lo reinicia tras cerrarlo), esto lo detecta
// solo y reconecta con el token guardado — sin que haga falta reabrir Ajustes
// y pulsar «Conectar» de nuevo. Se apoya en probe() (sondeo ligero sin auth).
let autoDetectTimer = null, connecting = false;
export function startAutoDetect(intervalMs = 4000) {
if (autoDetectTimer) return () => stopAutoDetect();
autoDetectTimer = setInterval(async () => {
if (isConnected() || connecting || !savedToken || pausado) return;
if (!(await probe())) return;
connecting = true;
try { await connectAuto(savedToken); } catch { /* el usuario aún no ha pegado token válido, o cayó de nuevo */ }
finally { connecting = false; }
}, intervalMs);
return () => stopAutoDetect();
}
export function stopAutoDetect() { clearInterval(autoDetectTimer); autoDetectTimer = null; }
// Cierra los trabajos que corrían por un socket que se ha caído.
function cerrarTrabajos(sock) {
for (const job of [...pending.values()]) {
if (job.sock !== sock) continue;
try { job.onErr('\n[bridge desconectado]\n'); } catch { /* quien escucha ya no está */ }
job.terminar(-1);
}
}
// Código de salida de un comando parado a mano, el mismo que da una shell con
// Ctrl+C (128 + SIGINT). Y el de un comando que agota su tiempo, el de timeout(1).
const PARADO = 130, SIN_TIEMPO = 124;
// ejecuta un comando REAL en la máquina del usuario, vía el bridge.
// onOut/onErr reciben trozos de salida en vivo; devuelve el código de salida.
//
// `signal` y `timeoutMs` lo PARAN: se le pide al bridge que mate el proceso
// ({type:'stop', id}, ya lo entendía) y se resuelve en el acto con 130 (124 si
// fue el tiempo). Antes no había forma de cortar un comando: parar el agente
// dejaba un `npm install` o un servidor corriendo en tu máquina, y el turno
// esperándolo.
export function exec(cmd, { cwd = savedFolder, onOut = () => {}, onErr = () => {}, signal = null, timeoutMs = 0 } = {}) {
if (!isConnected()) return Promise.reject(new Error('bridge no conectado'));
if (signal?.aborted) return Promise.resolve(PARADO);
const id = String(nextId++);
const sock = ws;
return new Promise((resolve, reject) => {
let timer = null;
const terminar = code => {
if (pending.get(id) !== job) return; // ya resuelto
pending.delete(id);
clearTimeout(timer);
signal?.removeEventListener('abort', alAbortar);
resolve(code);
};
const parar = code => {
try { sock.send(JSON.stringify({ type: 'stop', id })); } catch { /* socket cerrado: el proceso ya no es nuestro */ }
terminar(code);
};
const alAbortar = () => parar(PARADO);
const job = { onOut, onErr, sock, terminar };
pending.set(id, job);
try { sock.send(JSON.stringify({ type: 'exec', id, cmd, cwd })); }
catch (e) { pending.delete(id); reject(e); return; }
signal?.addEventListener('abort', alAbortar, { once: true });
if (timeoutMs > 0) timer = setTimeout(() => {
try { onErr('\n[bridge: tiempo agotado, proceso parado]\n'); } catch { /* */ }
parar(SIN_TIEMPO);
}, timeoutMs);
});
}
|