FilesExpand file tree

main

/

compartir.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

160 lines (146 loc) · 5.22 KB

main

/

compartir.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

160 lines (146 loc) · 5.22 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

#!/usr/bin/env node

import { spawn } from "node:child_process";

import { existsSync } from "node:fs";

import { join, dirname } from "node:path";

import { fileURLToPath } from "node:url";

/**

* Abre tu Multi al mundo por un túnel, para que un compa entre con un link.

*

* Qué hace, en orden: compila la Sala si hace falta, levanta el server (que la

* sirve en el MISMO puerto que la API — por eso basta un solo túnel), abre el

* túnel y te imprime el link.

*

* Lo que hay que decir en voz alta: mientras esto corre, tu máquina está

* expuesta a internet y cualquiera con el link entra a cualquier sala. Los ids

* son impredecibles, pero no hay más puerta que esa. Para una sesión con tus

* compas está bien; no lo dejes prendido.

*/

const raiz = join(dirname(fileURLToPath(import.meta.url)), "..");

const PUERTO = process.env.PORT ?? "4000";

const NPM = process.platform === "win32" ? "npm.cmd" : "npm";

function run(cmd, args, opts = {}) {

return spawn(cmd, args, { cwd: raiz, stdio: "inherit", shell: process.platform === "win32", ...opts });

}

function esperar(child) {

return new Promise((res, rej) => {

child.once("exit", (code) => (code === 0 ? res() : rej(new Error(`salió con ${code}`))));

child.once("error", rej);

});

}

async function main() {

// 1. La Sala compilada: sin esto el server no tiene qué servir y el túnel

// llevaría a una API pelona.

if (!existsSync(join(raiz, "web", "dist", "index.html"))) {

console.log("\n Compilando la Sala (solo la primera vez)…\n");

await esperar(run(NPM, ["run", "build"]));

}

console.log("\n Levantando Multi…\n");

const server = run(NPM, ["run", "serve"]);

// 2. Esperar a que responda antes de abrir el túnel: si no, ngrok muestra

// un error de conexión y parece que todo falló.

//

// El tope es alto porque el primer arranque hace varias cosas lentas:

// construir la imagen de Docker, y en WSL sobre /mnt/c hasta cargar las

// dependencias tarda (Windows traduciendo miles de lecturas).

const listo = await esperarServer(`http://localhost:${PUERTO}/health`, 600_000);

if (!listo) {

console.error("\n El server no respondió. Revisa los mensajes de arriba.\n");

server.kill();

process.exit(1);

}

console.log("\n Abriendo el túnel…\n");

const tunel = spawn("ngrok", ["http", PUERTO, "--log", "stdout", "--log-format", "json"], {

cwd: raiz,

stdio: ["ignore", "pipe", "pipe"],

});

let anunciado = false;

tunel.stdout.on("data", (d) => {

for (const linea of String(d).split("\n")) {

if (!linea.trim()) continue;

let ev;

try {

ev = JSON.parse(linea);

} catch {

continue;

}

if (ev.url && !anunciado) {

anunciado = true;

anunciar(ev.url);

}

// ngrok reporta sus errores por el mismo canal.

if (ev.lvl === "eror" || ev.err) {

console.error(` [ngrok] ${ev.err ?? ev.msg ?? linea}`);

}

}

});

tunel.stderr.on("data", (d) => process.stderr.write(` [ngrok] ${d}`));

tunel.once("exit", (code) => {

if (!anunciado) {

console.error(

[

"",

` ngrok no pudo abrir el túnel (salió con ${code}).`,

" Si es la primera vez, necesitas una cuenta gratis:",

" 1. Regístrate en https://dashboard.ngrok.com/signup",

" 2. Copia tu token y corre: ngrok config add-authtoken TU_TOKEN",

"",

].join("\n"),

);

}

server.kill();

process.exit(code ?? 1);

});

const cerrar = () => {

console.log("\n Cerrando…\n");

tunel.kill();

server.kill();

process.exit(0);

};

process.on("SIGINT", cerrar);

process.on("SIGTERM", cerrar);

}

function anunciar(url) {

console.log(

[

"",

" ─────────────────────────────────────────────────────",

"",

` Tu Multi está en: ${url}`,

"",

" Pásale ese link a tus compas y entran directo.",

" Cada quien pone su propia API key al llegar.",

"",

" Mientras esto corra, tu máquina está abierta a",

" internet: cierra con Ctrl+C cuando terminen.",

"",

" ─────────────────────────────────────────────────────",

"",

].join("\n"),

);

}

/** Sondea /health hasta que conteste. El primer arranque tarda (deps, Docker). */

async function esperarServer(url, timeoutMs) {

const limite = Date.now() + timeoutMs;

const inicio = Date.now();

let aviso = 0;

while (Date.now() < limite) {

// Avisar cada 30s: sin esto parece colgado y la gente lo mata.

const seg = Math.floor((Date.now() - inicio) / 1000);

if (seg >= aviso + 30) {

aviso = seg;

console.log(` …esperando al server (${seg}s). El primer arranque tarda.`);

}

try {

const r = await fetch(url, { signal: AbortSignal.timeout(3000) });

if (r.ok) return true;

} catch {

// todavía no levanta

}

await new Promise((r) => setTimeout(r, 1500));

}

return false;

}

main().catch((e) => {

console.error("\n Falló:", e.message, "\n");

process.exit(1);

});