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);
  });
}