localhostly 0.0.0-stage → 1.1.0

package/agente/servico/launchd.js

@@ -0,0 +1,100 @@
+// macOS: um LaunchAgent do usuário (~/Library/LaunchAgents/io.iblabs.localhostly.plist, `launchctl`), que sobe no
+// login (RunAtLoad) e é relançado pelo launchd quando cai (KeepAlive).
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ErroServico, executar } from './comum.js';
+
+export const ROTULO = 'io.iblabs.localhostly';
+
+export function arquivoDoPlist({ casa = homedir() } = {}) {
+  return join(casa, 'Library', 'LaunchAgents', `${ROTULO}.plist`);
+}
+
+export function arquivoDoLog({ casa = homedir() } = {}) {
+  return join(casa, 'Library', 'Logs', 'localhostly.log');
+}
+
+export function escaparXml(texto) {
+  return String(texto)
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+export function gerarPlist(comando, { log }) {
+  const str = (v) => `<string>${escaparXml(v)}</string>`;
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    '<dict>',
+    '  <key>Label</key>',
+    `  ${str(ROTULO)}`,
+    '  <key>ProgramArguments</key>',
+    '  <array>',
+    ...comando.map((a) => `    ${str(a)}`),
+    '  </array>',
+    '  <key>EnvironmentVariables</key>',
+    '  <dict>',
+    '    <key>NO_COLOR</key>',
+    '    <string>1</string>',
+    '  </dict>',
+    '  <key>RunAtLoad</key>',
+    '  <true/>',
+    '  <key>KeepAlive</key>',
+    '  <true/>',
+    '  <key>ThrottleInterval</key>',
+    '  <integer>5</integer>',
+    '  <key>ProcessType</key>',
+    '  <string>Background</string>',
+    '  <key>StandardOutPath</key>',
+    `  ${str(log)}`,
+    '  <key>StandardErrorPath</key>',
+    `  ${str(log)}`,
+    '</dict>',
+    '</plist>',
+    '',
+  ].join('\n');
+}
+
+function dominio(uid) {
+  return `gui/${uid}`;
+}
+
+export function instalar({ comando }, { casa, uid = process.getuid?.(), exec = executar } = {}) {
+  const arquivo = arquivoDoPlist({ casa });
+  const log = arquivoDoLog({ casa });
+  mkdirSync(join(arquivo, '..'), { recursive: true });
+  mkdirSync(join(log, '..'), { recursive: true });
+  // reinstalar troca a configuração: o agente de antes sai do launchd antes do novo entrar
+  exec('launchctl', ['bootout', `${dominio(uid)}/${ROTULO}`]);
+  writeFileSync(arquivo, gerarPlist(comando, { log }));
+  exec('launchctl', ['enable', `${dominio(uid)}/${ROTULO}`]);
+  const r = exec('launchctl', ['bootstrap', dominio(uid), arquivo]);
+  if (r.rc !== 0) {
+    throw new ErroServico(`could not load the LaunchAgent (launchctl bootstrap ${dominio(uid)}: exit ${r.rc})`, r.erro || r.saida);
+  }
+  return { arquivo, log: `tail -f ${log}`, avisos: [] };
+}
+
+export function remover({ casa, uid = process.getuid?.(), exec = executar } = {}) {
+  const arquivo = arquivoDoPlist({ casa });
+  const existia = existsSync(arquivo);
+  exec('launchctl', ['bootout', `${dominio(uid)}/${ROTULO}`]);
+  rmSync(arquivo, { force: true });
+  return { removido: existia, arquivo };
+}
+
+export function status({ casa, uid = process.getuid?.(), exec = executar } = {}) {
+  const arquivo = arquivoDoPlist({ casa });
+  if (!existsSync(arquivo)) return { instalado: false, arquivo };
+  const r = exec('launchctl', ['print', `${dominio(uid)}/${ROTULO}`]);
+  const base = { instalado: true, arquivo, sobeSozinho: true, log: `tail -f ${arquivoDoLog({ casa })}` };
+  if (r.rc !== 0) return { ...base, rodando: false, estado: 'not loaded', pid: null, sobeSozinho: false };
+  const estado = /^\s*state = (.+)$/m.exec(r.saida)?.[1]?.trim() ?? 'unknown';
+  const pid = Number(/^\s*pid = (\d+)/m.exec(r.saida)?.[1]) || null;
+  return { ...base, rodando: estado === 'running', estado, pid };
+}

package/agente/servico/systemd.js

@@ -0,0 +1,115 @@
+// Linux: um serviço do usuário no systemd (~/.config/systemd/user/localhostly.service, `systemctl --user`).
+// Sobe com a sessão do usuário; com `loginctl enable-linger`, com o computador, sem sessão aberta.
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir, userInfo } from 'node:os';
+import { join } from 'node:path';
+import { ErroServico, executar, NOME } from './comum.js';
+
+export const UNIDADE = `${NOME}.service`;
+
+export function arquivoDaUnidade({ casa = homedir(), env = process.env } = {}) {
+  return join(env.XDG_CONFIG_HOME || join(casa, '.config'), 'systemd', 'user', UNIDADE);
+}
+
+// Uma palavra do ExecStart: entre aspas quando precisa, com \ e " escapados; % e $ dobrados (o systemd os
+// expande como especificador e variável).
+export function citarSystemd(arg) {
+  const s = String(arg);
+  if (/[\n\r]/.test(s)) throw new Error('a service argument cannot contain a line break');
+  const literal = s.replaceAll('%', '%%').replaceAll('$', '$$$$');
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(s)) return literal;
+  return `"${literal.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+
+export function gerarUnidade(comando, { porta } = {}) {
+  return [
+    '[Unit]',
+    `Description=localhostly tunnel${porta ? ` to local port ${porta}` : ''}`,
+    'Documentation=https://localhostly.iblabs.io',
+    '',
+    '[Service]',
+    'Type=simple',
+    `ExecStart=${comando.map(citarSystemd).join(' ')}`,
+    'Environment=NO_COLOR=1',
+    'Restart=always',
+    'RestartSec=5',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+}
+
+function systemctl(exec, args, mensagem) {
+  const r = exec('systemctl', ['--user', ...args]);
+  if (r.rc === -1) throw new ErroServico('systemctl not found: this Linux does not run systemd');
+  if (r.rc !== 0 && /Failed to connect to bus|No medium found|DBUS_SESSION_BUS_ADDRESS/i.test(r.erro)) {
+    throw new ErroServico(
+      'the systemd user manager is not running for this user (no user session bus).\n' +
+        `Start it with \`sudo loginctl enable-linger ${userInfo().username}\` (it also keeps the tunnel up without a login) and try again.`,
+      r.erro,
+    );
+  }
+  if (mensagem && r.rc !== 0) {
+    throw new ErroServico(`${mensagem} (systemctl --user ${args.join(' ')}: exit ${r.rc})`, r.erro || r.saida);
+  }
+  return r;
+}
+
+// Sem linger, o gerenciador do usuário (e o túnel) só vive com uma sessão aberta.
+export function linger(exec = executar) {
+  const r = exec('loginctl', ['show-user', userInfo().username, '--property=Linger']);
+  if (r.rc !== 0) return null;
+  return /Linger=yes/.test(r.saida);
+}
+
+export function instalar({ comando, porta }, { casa, env, exec = executar } = {}) {
+  const arquivo = arquivoDaUnidade({ casa, env });
+  systemctl(exec, ['show-environment'], null); // falha cedo e com a dica se não há gerenciador do usuário
+  mkdirSync(join(arquivo, '..'), { recursive: true });
+  writeFileSync(arquivo, gerarUnidade(comando, { porta }));
+  systemctl(exec, ['daemon-reload'], 'could not reload systemd');
+  systemctl(exec, ['enable', UNIDADE], 'could not enable the service');
+  systemctl(exec, ['restart', UNIDADE], 'could not start the service');
+  const avisos = [];
+  if (linger(exec) === false) {
+    avisos.push(
+      'The tunnel runs while you are logged in. To keep it up after logout and start it at boot:\n' +
+        `  sudo loginctl enable-linger ${userInfo().username}`,
+    );
+  }
+  return { arquivo, log: `journalctl --user -u ${NOME} -f`, avisos };
+}
+
+export function remover({ casa, env, exec = executar } = {}) {
+  const arquivo = arquivoDaUnidade({ casa, env });
+  const existia = existsSync(arquivo);
+  if (existia) {
+    systemctl(exec, ['disable', '--now', UNIDADE], null);
+    rmSync(arquivo, { force: true });
+    systemctl(exec, ['daemon-reload'], null);
+  }
+  return { removido: existia, arquivo };
+}
+
+export function status({ casa, env, exec = executar } = {}) {
+  const arquivo = arquivoDaUnidade({ casa, env });
+  if (!existsSync(arquivo)) return { instalado: false, arquivo };
+  const r = systemctl(exec, ['show', UNIDADE, '--property=ActiveState,SubState,MainPID,UnitFileState'], null);
+  const campos = Object.fromEntries(
+    r.saida
+      .split('\n')
+      .filter((l) => l.includes('='))
+      .map((l) => [l.slice(0, l.indexOf('=')), l.slice(l.indexOf('=') + 1).trim()]),
+  );
+  const pid = Number(campos.MainPID) || null;
+  return {
+    instalado: true,
+    arquivo,
+    rodando: campos.ActiveState === 'active' && campos.SubState === 'running',
+    estado: campos.ActiveState ? `${campos.ActiveState} (${campos.SubState})` : 'unknown',
+    pid,
+    sobeSozinho: campos.UnitFileState === 'enabled',
+    log: `journalctl --user -u ${NOME} -f`,
+  };
+}

package/agente/servico/windows.js

@@ -0,0 +1,247 @@
+// Windows: um serviço de verdade (`sc.exe`, início automático, relançado pelo SCM se cair).
+//
+// O node não fala com o gerenciador de serviços (SCM): um node.exe direto no binPath não chama
+// StartServiceCtrlDispatcher e o SCM o derruba em 30 s (erro 1053). Então a instalação compila, com o csc.exe do
+// .NET Framework 4 que todo Windows 10/11 traz, um supervisor mínimo (o C# abaixo, sem dependência): ele é o
+// serviço, roda o agente em `--service` como processo filho, guarda a saída em service.log e o relança 5 s depois
+// de sair; parar o serviço mata o filho.
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ErroServico, executar } from './comum.js';
+
+export const SERVICO = 'Localhostly';
+
+export const FONTE_SUPERVISOR = String.raw`// localhostly: o supervisor do serviço do Windows (gerado por localhostly service install).
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.ServiceProcess;
+using System.Text;
+using System.Threading;
+
+public class LocalhostlyServico : ServiceBase {
+  readonly string log;
+  readonly string exe;
+  readonly string args;
+  readonly object trava = new object();
+  volatile bool parando;
+  Process filho;
+
+  // args: <log> <exe> <args do agente...>
+  public LocalhostlyServico(string[] a) {
+    ServiceName = "Localhostly";
+    CanStop = true;
+    CanShutdown = true;
+    log = a[0];
+    exe = a[1];
+    var resto = new StringBuilder();
+    for (int i = 2; i < a.Length; i++) { if (i > 2) resto.Append(' '); resto.Append(Citar(a[i])); }
+    args = resto.ToString();
+  }
+
+  // As regras do CommandLineToArgvW: aspas em volta, \ antes de " dobradas.
+  public static string Citar(string s) {
+    if (s.Length > 0 && s.IndexOfAny(new[] { ' ', '\t', '"' }) < 0) return s;
+    var b = new StringBuilder("\"");
+    int barras = 0;
+    foreach (char c in s) {
+      if (c == '\\') { barras++; continue; }
+      if (c == '"') { b.Append('\\', barras * 2 + 1); b.Append('"'); }
+      else { b.Append('\\', barras); b.Append(c); }
+      barras = 0;
+    }
+    b.Append('\\', barras * 2);
+    b.Append('"');
+    return b.ToString();
+  }
+
+  void Escrever(string linha) {
+    if (linha == null) return;
+    lock (trava) {
+      try {
+        var info = new FileInfo(log);
+        if (info.Exists && info.Length > 10L * 1024 * 1024) {
+          File.Copy(log, log + ".1", true);
+          File.WriteAllText(log, "");
+        }
+        File.AppendAllText(log, linha + Environment.NewLine);
+      } catch { }
+    }
+  }
+
+  public void Rodar() {
+    while (!parando) {
+      try {
+        var psi = new ProcessStartInfo(exe, args);
+        psi.UseShellExecute = false;
+        psi.CreateNoWindow = true;
+        psi.RedirectStandardOutput = true;
+        psi.RedirectStandardError = true;
+        psi.EnvironmentVariables["NO_COLOR"] = "1";
+        var p = new Process();
+        p.StartInfo = psi;
+        p.OutputDataReceived += (s, e) => Escrever(e.Data);
+        p.ErrorDataReceived += (s, e) => Escrever(e.Data);
+        p.Start();
+        filho = p;
+        p.BeginOutputReadLine();
+        p.BeginErrorReadLine();
+        p.WaitForExit();
+        if (!parando) Escrever(DateTime.UtcNow.ToString("o") + " agent exited with code " + p.ExitCode + "; restarting in 5s");
+      } catch (Exception e) {
+        Escrever(DateTime.UtcNow.ToString("o") + " could not start the agent: " + e.Message);
+      }
+      for (int i = 0; i < 50 && !parando; i++) Thread.Sleep(100);
+    }
+  }
+
+  protected override void OnStart(string[] ignorados) {
+    var t = new Thread(Rodar);
+    t.IsBackground = true;
+    t.Start();
+  }
+
+  protected override void OnStop() {
+    parando = true;
+    try { if (filho != null && !filho.HasExited) filho.Kill(); } catch { }
+  }
+
+  protected override void OnShutdown() { OnStop(); }
+
+  // --console: o mesmo laço em primeiro plano, para testar sem instalar o serviço.
+  public static void Main(string[] a) {
+    if (a.Length > 0 && a[0] == "--console") {
+      var resto = new string[a.Length - 1];
+      Array.Copy(a, 1, resto, 0, resto.Length);
+      new LocalhostlyServico(resto).Rodar();
+      return;
+    }
+    ServiceBase.Run(new LocalhostlyServico(a));
+  }
+}
+`;
+
+// Uma palavra da linha de comando do Windows (as regras do CommandLineToArgvW, as mesmas do Citar do supervisor).
+export function citarWindows(arg) {
+  const s = String(arg);
+  if (s.length > 0 && !/[\s"]/.test(s)) return s;
+  let saida = '"';
+  let barras = 0;
+  for (const c of s) {
+    if (c === '\\') {
+      barras++;
+      continue;
+    }
+    if (c === '"') saida += `${'\\'.repeat(barras * 2 + 1)}"`;
+    else saida += `${'\\'.repeat(barras)}${c}`;
+    barras = 0;
+  }
+  return `${saida}${'\\'.repeat(barras * 2)}"`;
+}
+
+export function caminhos(home) {
+  const pasta = join(home, 'service');
+  return {
+    pasta,
+    fonte: join(pasta, 'localhostly-service.cs'),
+    supervisor: join(pasta, 'localhostly-service.exe'),
+    log: join(home, 'service.log'),
+  };
+}
+
+// O binPath do serviço: o supervisor, o log e o comando do agente, cada um citado.
+export function binPath(supervisor, log, comando) {
+  return [supervisor, log, ...comando].map(citarWindows).join(' ');
+}
+
+// Os argumentos do sc.exe (cada item é um argumento; o node os cita ao chamar, e o sc.exe recebe o binPath com
+// as aspas de dentro intactas). `criar`: create na primeira vez, config quando o serviço já existe.
+export function argumentosSc(binPathTexto, { criar = true } = {}) {
+  return [
+    criar ? 'create' : 'config',
+    SERVICO,
+    'binPath=',
+    binPathTexto,
+    'start=',
+    'auto',
+    'DisplayName=',
+    'localhostly tunnel',
+  ];
+}
+
+function cscDoSistema(env) {
+  const windir = env.WINDIR || env.SystemRoot || 'C:\\Windows';
+  for (const fw of ['Framework64', 'Framework']) {
+    const csc = join(windir, 'Microsoft.NET', fw, 'v4.0.30319', 'csc.exe');
+    if (existsSync(csc)) return csc;
+  }
+  return null;
+}
+
+export function compilarSupervisor(home, { env = process.env, exec = executar, csc = cscDoSistema(env) } = {}) {
+  const c = caminhos(home);
+  if (!csc) throw new ErroServico('csc.exe (.NET Framework 4) not found: cannot build the service host');
+  mkdirSync(c.pasta, { recursive: true });
+  writeFileSync(c.fonte, FONTE_SUPERVISOR);
+  const r = exec(csc, ['/nologo', '/target:winexe', `/out:${c.supervisor}`, '/reference:System.ServiceProcess.dll', c.fonte]);
+  if (r.rc !== 0) throw new ErroServico(`could not build the service host (csc.exe: exit ${r.rc})`, r.saida || r.erro);
+  return c;
+}
+
+const NAO_EXISTE = /\b1060\b/;
+const SEM_ADMIN = /\b5\b.*(denied|negado)|Access is denied|Acesso negado|OpenSCManager FAILED 5/i;
+
+function sc(exec, args) {
+  return exec('sc.exe', args);
+}
+
+function exigirSc(exec, args, mensagem) {
+  const r = sc(exec, args);
+  if (r.rc === 0) return r;
+  const texto = `${r.saida}\n${r.erro}`;
+  if (SEM_ADMIN.test(texto)) {
+    throw new ErroServico('Windows services need an elevated terminal: open it with "Run as administrator" and try again.');
+  }
+  throw new ErroServico(`${mensagem} (sc.exe ${args[0]}: exit ${r.rc})`, texto);
+}
+
+export function instalar({ comando, home }, { env = process.env, exec = executar, cscPadrao } = {}) {
+  const c = compilarSupervisor(home, { env, exec, csc: cscPadrao ?? cscDoSistema(env) });
+  const existe = !NAO_EXISTE.test(`${sc(exec, ['query', SERVICO]).saida}`);
+  if (existe) sc(exec, ['stop', SERVICO]);
+  exigirSc(exec, argumentosSc(binPath(c.supervisor, c.log, comando), { criar: !existe }), 'could not create the service');
+  sc(exec, ['description', SERVICO, 'Keeps the localhostly tunnel up (https://localhostly.iblabs.io).']);
+  sc(exec, ['failure', SERVICO, 'reset=', '86400', 'actions=', 'restart/5000/restart/5000/restart/5000']);
+  exigirSc(exec, ['start', SERVICO], 'could not start the service');
+  return { arquivo: c.supervisor, log: c.log, avisos: [] };
+}
+
+export function remover({ home, exec = executar } = {}) {
+  const q = sc(exec, ['query', SERVICO]);
+  const existia = !NAO_EXISTE.test(`${q.saida}\n${q.erro}`) && q.rc !== -1;
+  if (existia) {
+    sc(exec, ['stop', SERVICO]);
+    exigirSc(exec, ['delete', SERVICO], 'could not remove the service');
+  }
+  if (home) rmSync(caminhos(home).pasta, { recursive: true, force: true });
+  return { removido: existia, arquivo: SERVICO };
+}
+
+const ESTADOS = { 1: 'stopped', 2: 'starting', 3: 'stopping', 4: 'running', 5: 'resuming', 6: 'pausing', 7: 'paused' };
+
+export function status({ home, exec = executar } = {}) {
+  const r = sc(exec, ['queryex', SERVICO]);
+  if (r.rc === -1 || NAO_EXISTE.test(`${r.saida}\n${r.erro}`)) return { instalado: false, arquivo: SERVICO };
+  const codigo = Number(/STATE\s*:\s*(\d+)/.exec(r.saida)?.[1]);
+  const pid = Number(/PID\s*:\s*(\d+)/.exec(r.saida)?.[1]) || null;
+  const config = sc(exec, ['qc', SERVICO]).saida;
+  return {
+    instalado: true,
+    arquivo: SERVICO,
+    rodando: codigo === 4,
+    estado: ESTADOS[codigo] ?? 'unknown',
+    pid,
+    sobeSozinho: /AUTO_START/.test(config),
+    log: home ? caminhos(home).log : null,
+  };
+}

package/agente/tela.js

@@ -0,0 +1,72 @@
+// A tela do agente: a URL e uma linha por requisição, sem dependência.
+const CORES = { verde: 32, amarelo: 33, vermelho: 31, ciano: 36, cinza: 90, negrito: 1 };
+
+function hora(d = new Date()) {
+  return d.toTimeString().slice(0, 8);
+}
+
+export function criarTela(saida = process.stdout, { cor = Boolean(saida.isTTY) && !process.env.NO_COLOR } = {}) {
+  const pintar = (nome, texto) => (cor ? `\x1b[${CORES[nome]}m${texto}\x1b[0m` : texto);
+  const linha = (texto) => saida.write(`${texto}\n`);
+
+  function corDoStatus(status) {
+    if (status >= 500 || status === 0) return 'vermelho';
+    if (status >= 400) return 'amarelo';
+    if (status >= 300) return 'ciano';
+    return 'verde';
+  }
+
+  return {
+    conectando(servidor) {
+      linha(pintar('cinza', `connecting to ${servidor}…`));
+    },
+    // senha: o texto (a gerada, que só esta tela mostra), true (a que o usuário escolheu) ou nada.
+    // permitidos: a lista do --allow (só esses endereços entram) ou nada.
+    pronto({ url, alvo, senha = null, permitidos = null }) {
+      linha('');
+      linha(`${pintar('negrito', url)} → http://${alvo}`);
+      if (permitidos?.length) linha(`Allowed: ${pintar('negrito', permitidos.join(', '))} ${pintar('cinza', '(other addresses get 403)')}`);
+      if (typeof senha === 'string') linha(`Password: ${pintar('negrito', senha)} ${pintar('cinza', '(any user name)')}`);
+      else if (senha) linha(pintar('cinza', 'Password protected (any user name).'));
+      linha(pintar('cinza', 'Ctrl+C to stop. Requests:'));
+      linha('');
+    },
+    requisicao({ metodo, caminho, status, ms }, quando = new Date()) {
+      const c = caminho.length > 60 ? `${caminho.slice(0, 59)}…` : caminho;
+      linha(
+        `${pintar('cinza', hora(quando))}  ${metodo.padEnd(7)} ${c.padEnd(40)} ` +
+          `${pintar(corDoStatus(status), String(status || '---'))} ${pintar('cinza', `${ms}ms`)}`,
+      );
+    },
+    aviso(texto) {
+      linha(pintar('amarelo', texto));
+    },
+    erro(texto) {
+      linha(pintar('vermelho', texto));
+    },
+  };
+}
+
+// O modo serviço (--service): sem tabela ao vivo nem cor; uma linha por evento, com a hora, no stdout que o
+// systemd (journal), o launchd e o serviço do Windows guardam.
+export function criarLog(saida = process.stdout, { relogio = () => new Date() } = {}) {
+  const linha = (texto) => saida.write(`${relogio().toISOString()} ${texto}\n`);
+  return {
+    conectando(servidor) {
+      linha(`connecting to ${servidor}`);
+    },
+    pronto({ url, alvo, senha = null, retomado = false, permitidos = null }) {
+      linha(
+        `online ${url} -> http://${alvo}${retomado ? ' (same name)' : ''}${senha ? ' (password protected)' : ''}` +
+          `${permitidos?.length ? ` (allowed: ${permitidos.join(',')})` : ''}`,
+      );
+    },
+    requisicao() {},
+    aviso(texto) {
+      linha(texto);
+    },
+    erro(texto) {
+      linha(`error: ${texto}`);
+    },
+  };
+}