@mmmbuto/nexuscrew 0.8.46 → 0.8.48

package/lib/proxy/federation.js

@@ -17,6 +17,48 @@ const { signHop, HOP_HEADER } = require('./hop-proof.js');
 const MAX_HOPS = 4;
 const ROUTE_DELIMITER = '_';
 const TOPOLOGY_PEER_TIMEOUT_MS = 1500;
+// Finestra di attesa del reverse channel su Share ON: limitata per non
+// diventare un retry storm, ma sufficiente al bind subito dopo un pairing.
+const SHARE_HEALTH_ATTEMPTS = 10;
+const SHARE_HEALTH_DELAY_MS = 300;
+const SHARE_NOT_READY_CODE = 'share-channel-not-ready';
+// 500/502/503/504 sono indisponibilita' che passano; 501 e 505 no.
+const TRANSIENT_HTTP_STATUS = new Set([500, 502, 503, 504]);
+// Esiti della prova di slot che significano "non ottenuta" e non "sbagliata".
+const SLOT_PROOF_UNAVAILABLE = 'reverse-slot-proof-unavailable';
+
+// Classificazione dell'esito di Share ON. La regola e' fail-closed sul
+// RITENTATIVO: e' ritentabile solo cio' che e' dimostrabilmente transitorio —
+// il canale non ancora salito. Tutto il resto (credenziale non valida, nodo
+// sbagliato in fondo al tunnel, prova di slot non corrispondente) e' un guasto
+// che il tempo non ripara, e ritentarlo nasconde all'operatore la vera causa.
+function classifyShareFailure(health) {
+  const detail = (health && health.detail) || 'reverse SSH non pronto';
+  if (!health) return { code: 'share-peer-unreachable', detail };
+  // Credenziale non valida: serve un re-pair, il tempo non la ripara.
+  if (health.auth === 'failed') return { code: 'share-peer-unauthorized', detail };
+  if (health.slotProof === true) {
+    // Attenzione: `probeReverseSlot` marca "non posseduta" anche quando la
+    // prova non e' stata OTTENUTA — timeout, connessione rifiutata, risposta
+    // non 200 — che e' un canale non ancora su, non una prova sbagliata.
+    // Confonderli renderebbe finale proprio il caso che vogliamo attendere.
+    return health.code === SLOT_PROOF_UNAVAILABLE
+      ? { code: SHARE_NOT_READY_CODE, detail }
+      : { code: 'share-slot-proof-failed', detail };
+  }
+  if (health.transport === 'down') return { code: SHARE_NOT_READY_CODE, detail };
+  // Il peer risponde ma con un errore server: indisponibilita' temporanea, non
+  // il nodo sbagliato in fondo al tunnel. Allowlist esplicita invece di "ogni
+  // 5xx": 501 e 505 dicono che quella richiesta non sara' MAI servita, e
+  // ritentarle sarebbe rumore.
+  if (TRANSIENT_HTTP_STATUS.has(health.httpStatus)) {
+    return { code: SHARE_NOT_READY_CODE, detail };
+  }
+  // Qui il peer ha risposto 200 ma non e' quello atteso (instanceId o payload):
+  // ritentare non lo trasforma nel nodo giusto.
+  if (health.reachability === 'failed') return { code: 'share-peer-mismatch', detail };
+  return { code: 'share-peer-unreachable', detail };
+}
 
 function peerFromToken(nodesPath, token) {
   const st = store.loadStore(nodesPath);
@@ -381,7 +423,18 @@ async function notifyHubShare({ node, shared, fetchImpl = fetch, timeoutMs = 500
       }, budget);
     });
     const response = await Promise.race([request, timeout]);
-    if (!response || !response.ok) throw new Error(`hub Share HTTP ${response && response.status || 'unknown'}`);
+    if (!response || !response.ok) {
+      const failure = new Error(`hub Share HTTP ${response && response.status || 'unknown'}`);
+      failure.status = response && response.status;
+      // Si estrae SOLO il codice tipizzato: il corpo remoto non entra mai nel
+      // messaggio d'errore ne' nei log. Un corpo non-JSON lascia il codice
+      // assente e l'errore resta definitivo, che e' il default sicuro.
+      try {
+        const body = typeof response.json === 'function' ? await response.json() : null;
+        if (body && typeof body.code === 'string' && body.code.length <= 64) failure.code = body.code;
+      } catch (_) { /* corpo assente o non-JSON: nessun codice */ }
+      throw failure;
+    }
     return { shared };
   } finally { clearTimeout(timer); }
 }
@@ -593,7 +646,14 @@ async function collectTopologyDetailed({
     if (!n.nodeId || seen.has(n.nodeId)
       || (!ingress && n.direction === 'inbound' && n.shared !== true)
       || (ingress && !canTransit(ingress, n))) continue;
-    out.push({ instanceId: n.nodeId, name: n.name, route: [n.name], direct: true });
+    // `name` e' lo slug locale con cui si indirizza; `label` e' il nome
+    // leggibile. Senza quest'ultimo un nodo raggiunto in transito arriva agli
+    // altri come uno slug scelto da qualcun altro, e cinque installazioni
+    // diverse si presentano con lo stesso nome.
+    out.push({
+      instanceId: n.nodeId, name: n.name, route: [n.name], direct: true,
+      label: store.validLabel(n.label) ? n.label.trim() : '',
+    });
     if (ttl <= 1 || !n.token) continue;
     probes.push({ n, pending: fetchPeerTopology({ node: n, ttl, seen, fetchImpl, timeoutMs }) });
   }
@@ -611,7 +671,15 @@ async function collectTopologyDetailed({
           || new Set(child.route).size !== child.route.length
           || child.name !== child.route[child.route.length - 1]
           || child.route.includes(n.name)) continue;
-        out.push({ instanceId: child.instanceId, name: child.name, route: [n.name, ...child.route], direct: false });
+        // La label di un nodo in transito e' testo AUTO-DICHIARATO da un altro
+        // nodo: si accetta solo se rispetta la stessa forma di una label locale,
+        // altrimenti si resta senza nome invece di propagare qualcosa di
+        // arbitrario. Non e' mai una prova di identita': quella e' l'instanceId.
+        out.push({
+          instanceId: child.instanceId, name: child.name,
+          route: [n.name, ...child.route], direct: false,
+          label: store.validLabel(child.label) ? child.label.trim() : '',
+        });
     }
   }
   const ids = new Set(); const routes = new Set(); const unique = [];
@@ -653,7 +721,15 @@ async function collectLocalTopology({
     next.set(entry.instanceId, entry);
   }
   for (const n of live.nodes) {
-    if (n.route.length > 1) next.set(n.instanceId, { instanceId: n.instanceId, name: n.name, route: [...n.route], lastSeen: now });
+    // La cache conserva anche la label: senza, un nodo che torna stale perde il
+    // nome e ricompare come slug, cioe' esattamente il difetto che si voleva
+    // togliere. Resta un dato riferito, non una prova.
+    if (n.route.length > 1) {
+      next.set(n.instanceId, {
+        instanceId: n.instanceId, name: n.name, route: [...n.route],
+        ...(n.label ? { label: n.label } : {}), lastSeen: now,
+      });
+    }
   }
   const cached = [...next.values()].sort((a, b) => a.route.join('/').localeCompare(b.route.join('/'))).slice(0, topologyCache.MAX_ENTRIES);
   const serialized = { schemaVersion: topologyCache.SCHEMA_VERSION, nodes: cached };
@@ -895,12 +971,19 @@ function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly
     }
     try {
       if (body.shared) {
+        // Il reverse channel viene stabilito dal peer subito prima di questa
+        // chiamata: appena dopo un pairing il bind non e' ancora pronto e la
+        // finestra breve trasformava un'attesa in un fallimento definitivo,
+        // con rollback dell'intera transazione lato peer. La finestra resta
+        // limitata (nessun retry storm) ma copre il caso reale.
         let health;
         if (req.peer.reversePool) {
-          for (let attempt = 0; attempt < 6; attempt += 1) {
+          for (let attempt = 0; attempt < SHARE_HEALTH_ATTEMPTS; attempt += 1) {
             health = await probeReverseOwner(req.peer, fetchImpl || fetch);
             if (health.status === 'healthy') break;
-            if (attempt < 5) await new Promise((resolve) => setTimeout(resolve, 200));
+            if (attempt < SHARE_HEALTH_ATTEMPTS - 1) {
+              await new Promise((resolve) => setTimeout(resolve, SHARE_HEALTH_DELAY_MS));
+            }
           }
         } else {
           health = await waitForHealthyPeer({
@@ -908,14 +991,19 @@ function peerRouter({ nodesPath, localPort, localCredential, fetchImpl, readonly
             token: req.peer.token,
             expectedInstanceId: req.peer.nodeId || null,
             fetchImpl: fetchImpl || fetch,
-            attempts: 6,
-            delayMs: 200,
+            attempts: SHARE_HEALTH_ATTEMPTS,
+            delayMs: SHARE_HEALTH_DELAY_MS,
           });
         }
         if (health.status !== 'healthy') {
+          // Codice tipizzato: chi chiama deve poter distinguere un'attesa da un
+          // guasto definitivo senza interpretare una stringa. Solo il canale
+          // non ancora salito e' ritentabile.
+          const failure = classifyShareFailure(health);
           return res.status(409).json({
             error: 'canale share non raggiungibile',
-            detail: health.detail || 'reverse SSH non pronto',
+            code: failure.code,
+            detail: failure.detail,
           });
         }
       }
@@ -980,7 +1068,7 @@ function forwardUpgrade({ req, socket, head, nodesPath, localPort, localCredenti
 function reject(socket, code) { try { socket.end(`HTTP/1.1 ${code} Error\r\nConnection: close\r\n\r\n`); } catch (_) {} }
 
 module.exports = {
-  MAX_HOPS, ROUTE_DELIMITER, TOPOLOGY_PEER_TIMEOUT_MS,
+  MAX_HOPS, ROUTE_DELIMITER, TOPOLOGY_PEER_TIMEOUT_MS, SHARE_NOT_READY_CODE, classifyShareFailure,
   peerFromToken, peerAllows, canTransit, parseRoute, knownResource, allowedResource, allowedQuery, readonlyBlocksFederated,
   collectTopology, collectTopologyDetailed, collectLocalTopology, peerRouter, localRouter, forwardUpgrade,
   probeHealth, waitForHealthyPeer, canListenLoopback, preflightHubReverse, notifyHubShare, reconcilePeerShare, runShareRevokeBoot, probeReverseOwner,

package/lib/server.js

@@ -227,15 +227,19 @@ function createServer(opts = {}) {
     }
     const selected = [...entries.values()].filter((entry) => (remotePort === null || entry.remotePort === remotePort)
       && (generation === null || entry.generation === generation));
-    let stopped = false;
+    // Il valore di ritorno significa "TUTTE le entry selezionate sono spente in
+    // modo dimostrabile". Durante la grace di una rotazione ne coesistono due:
+    // dichiarare successo perche' UNA e' stata chiusa lascerebbe l'altra viva
+    // mentre chi chiama registra il canale come privato.
+    const outcomes = [];
     for (const existing of selected) {
       const result = nodesTunnel.stopTunnel({ home: cfg.home || os.homedir(), name: nodesTunnel.reverseTunnelName(name, existing.remotePort, existing.generation) });
+      outcomes.push(result);
       // If we cannot prove ownership we neither signal nor close the listener:
       // the channel is quarantined for diagnostics rather than broken by us.
-      if (!result.stopped && !['no pidfile', 'stale (pid dead)'].includes(result.reason)) continue;
+      if (!reverseRotation.stopWasDemonstrated(result)) continue;
       entries.delete(reverseKey(existing.remotePort, existing.generation));
       await reverseSlotListeners?.closePort(existing.localPort);
-      stopped = true;
     }
     if (!entries.size) rotatableReverse.delete(name);
     if (remotePort === null && generation === null) {
@@ -243,7 +247,11 @@ function createServer(opts = {}) {
       if (watcher) clearInterval(watcher);
       reverseWatchers.delete(name);
     }
-    return stopped;
+    // La decisione vive in `summarizeStops` (funzione pura, testabile senza
+    // processi): successo solo se qualcosa e' stato spento E niente e' rimasto
+    // in quarantena. Il caso "nessuna entry" resta false come prima: non si
+    // puo' dimostrare nulla.
+    return reverseRotation.summarizeStops(outcomes).allClosed;
   }
   async function verifyRotatablePool(node) {
     const pool = node?.reversePool;
@@ -473,7 +481,12 @@ function createServer(opts = {}) {
   }
 
   const app = express();
-  reverseSlotListeners = createReverseSlotListeners({ app, diagnostics, createServerImpl: cfg.reverseSlotCreateServerImpl });
+  reverseSlotListeners = createReverseSlotListeners({
+    app, diagnostics, createServerImpl: cfg.reverseSlotCreateServerImpl,
+    // `routeUpgrade` e' hoisted: qui si cattura solo il riferimento, la
+    // chiamata avviene quando arriva un upgrade, a server avviato.
+    attachUpgrade: (slotServer) => slotServer.on('upgrade', routeUpgrade),
+  });
   const distDir = path.join(__dirname, '..', 'frontend', 'dist');
   // no-store on everything (HTML+assets+API): this is a local, token-adjacent tool.
   app.use((_req, res, next) => { res.set('Cache-Control', 'no-store'); next(); });
@@ -795,7 +808,13 @@ function createServer(opts = {}) {
   }, opts.wsHeartbeatMs || 30000);
   if (typeof heartbeat.unref === 'function') heartbeat.unref();
   server.on('close', () => clearInterval(heartbeat));
-  server.on('upgrade', (req, socket, head) => {
+  // Routing dell'upgrade WS. Dichiarata come funzione (hoisted nello scope di
+  // createServer) perche' i listener per-slot nascono PRIMA di questo punto e
+  // devono ricevere lo STESSO routing: un listener che serve `app` senza
+  // handler di upgrade fa cadere l'upgrade su Express, che non ha una rotta
+  // HTTP `/ws` e risponde con la SPA (200) invece di 101 -> terminale nero su
+  // ogni peer raggiunto via reverse pool.
+  function routeUpgrade(req, socket, head) {
     let pathname;
     try { pathname = new URL(req.url, 'http://127.0.0.1').pathname; }
     catch (_) { try { socket.destroy(); } catch (_e) {} return; }
@@ -826,7 +845,8 @@ function createServer(opts = {}) {
       return;
     }
     try { socket.destroy(); } catch (_) {}
-  });
+  }
+  server.on('upgrade', routeUpgrade);
   wss.on('connection', (ws, req) => {
     ws.isAlive = true;
     ws.on('pong', () => { ws.isAlive = true; });

package/lib/settings/routes.js

@@ -52,7 +52,9 @@ const audioGroups = require('../audio/groups.js');
 const nodesCmds = require('../nodes/commands.js');
 const nodesTunnel = require('../nodes/tunnel.js');
 const peering = require('../nodes/peering.js');
-const { waitForHealthyPeer, preflightHubReverse, notifyHubShare, reconcilePeerShare } = require('../proxy/federation.js');
+const {
+  waitForHealthyPeer, preflightHubReverse, notifyHubShare, reconcilePeerShare, SHARE_NOT_READY_CODE,
+} = require('../proxy/federation.js');
 const { rotateToken } = require('../auth/token.js');
 const { generateService, installService, installPath: svcInstallPath } = require('../cli/service.js');
 const { detectPlatform, nodeBin, repoRoot, uid } = require('../cli/platform.js');
@@ -597,8 +599,45 @@ function settingsRoutes(deps = {}) {
     const wasShared = node.shared === true;
     let persistedDesired = wasShared;
     let shareOnAttempted = false;
+    // Traccia se il rollback ha davvero spento il canale reverse. Resta true
+    // finche' non si tenta una chiusura che non riesce a dimostrarsi.
+    let reverseChannelClosed = true;
+    // `close` restituisce false quando non riesce a DIMOSTRARE la proprieta'
+    // del supervisor: il canale resta in quarantena, vivo. Una chiusura che
+    // LANCIA non e' una chiusura riuscita: stesso esito, altrimenti l'unico
+    // caso in cui non sappiamo nulla sarebbe anche l'unico che tace.
+    const closeReverseChannel = async () => {
+      if (!node.reversePool || typeof reverseSlots?.close !== 'function') return;
+      try {
+        reverseChannelClosed = (await reverseSlots.close(name)) !== false;
+      } catch (_) {
+        reverseChannelClosed = false;
+      }
+    };
     const fetchImpl = seams.fetchImpl || fetch;
-    const notifyHub = (shared) => notifyHubShare({ node, shared, fetchImpl, timeoutMs: 5000 });
+    const notifyHubOnce = (shared) => notifyHubShare({ node, shared, fetchImpl, timeoutMs: 5000 });
+    // Share ON stabilisce il reverse channel un istante prima di annunciarlo:
+    // subito dopo un pairing il bind sul hub non e' ancora pronto e l'hub
+    // risponde con un codice tipizzato ritentabile. Senza questo ritentativo
+    // limitato l'attesa diventava un fallimento definitivo, con rollback
+    // dell'intera transazione e Share che "non funziona" finche' l'operatore
+    // non riprova a mano. Qualunque altro errore resta definitivo.
+    const NOTIFY_RETRY_DELAYS_MS = [1000, 2000, 3000];
+    const notifyDelay = typeof seams.pairDelay === 'function'
+      ? seams.pairDelay
+      : (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    const notifyHub = async (shared) => {
+      if (!shared) return notifyHubOnce(false);
+      let last;
+      for (let attempt = 0; attempt <= NOTIFY_RETRY_DELAYS_MS.length; attempt += 1) {
+        try { return await notifyHubOnce(true); } catch (e) {
+          last = e;
+          if (!e || e.code !== SHARE_NOT_READY_CODE) throw e;
+          if (attempt < NOTIFY_RETRY_DELAYS_MS.length) await notifyDelay(NOTIFY_RETRY_DELAYS_MS[attempt]);
+        }
+      }
+      throw last;
+    };
     const ensureLocal = async ({ restart = false } = {}) => {
       const stopForward = seams.stopTunnelImpl || nodesTunnel.stopTunnel;
       const startForward = seams.startForwardImpl || nodesTunnel.startForward;
@@ -639,7 +678,9 @@ function settingsRoutes(deps = {}) {
       nodesStore.atomicWriteStore(nodesPath, st);
       persistedDesired = shared;
       node = nodesStore.getNode(st, name);
-      if (!shared && node.reversePool && typeof reverseSlots?.close === 'function') await reverseSlots.close(name);
+      // Lo stato persistito direbbe "privato" mentre il reverse pool e' ancora
+      // su: l'esito della chiusura va riportato a chi chiama, non ignorato.
+      if (!shared) await closeReverseChannel();
       await ensureLocal({ restart: true });
     };
     const revokeHub = () => reconcilePeerShare({
@@ -659,7 +700,10 @@ function settingsRoutes(deps = {}) {
           detail: scrubError(revokeErr),
         });
       }
-      if (node.reversePool && typeof reverseSlots?.close === 'function') await reverseSlots.close(name);
+      // Stessa regola del rollback: una chiusura non dimostrabile lascia il
+      // canale in quarantena, vivo. Qui finisce in una risposta di SUCCESSO,
+      // quindi tacerlo e' peggio: dichiarerebbe revocato cio' che e' sospeso.
+      await closeReverseChannel();
       try {
         // A changed ON->OFF spec is restarted explicitly; same-state OFF uses
         // the idempotent spec-aware path, which only replaces a stale -R.
@@ -673,6 +717,7 @@ function settingsRoutes(deps = {}) {
       }
       return send(res, 200, {
         name, shared: false, revoked: true,
+        ...(reverseChannelClosed ? {} : { reversePoolPending: true }),
         ...(unchanged ? { unchanged: true, reconciled: true } : {}),
       });
     };
@@ -742,7 +787,11 @@ function settingsRoutes(deps = {}) {
       // Share-on is transactional: a failed hub acknowledgement returns to the
       // safe private -L-only state. Never include remote response bodies/tokens.
       if (body.shared && !wasShared && shareOnAttempted) {
-        try { await applyLocal(false); } catch (_) { /* best-effort safe rollback */ }
+        // Il rollback resta best-effort — non si puo' fallire due volte — ma il
+        // suo esito NON si perde: se il canale reverse non e' stato spento in
+        // modo dimostrabile, chi chiama deve saperlo invece di leggere solo
+        // "Share non attivato" e credere che tutto sia tornato privato.
+        try { await applyLocal(false); } catch (_) { reverseChannelClosed = false; }
       }
       const offPersisted = body.shared === false && persistedDesired === false;
       const redact = (value) => String(value || '').replace(/Bearer\s+\S+/gi, 'Bearer ***');
@@ -753,6 +802,10 @@ function settingsRoutes(deps = {}) {
           : 'Share non attivato')
           : offPersisted ? 'Share disattivato localmente; hub non riconciliato' : 'Share non disattivato',
         ...(offPersisted ? { shared: false, reconcilePending: true } : {}),
+        // Segnale esplicito quando lo store dice privato ma il canale reverse
+        // non risulta spento in modo dimostrabile: e' una quarantena, non una
+        // chiusura, e va diagnosticata invece che dedotta.
+        ...(reverseChannelClosed ? {} : { reversePoolPending: true }),
         ...(e && typeof e.code === 'string' ? { code: e.code } : {}),
         detail: redact(e && e.message || e),
         ...(e && typeof e.hint === 'string' ? { hint: redact(e.hint) } : {}),

package/lib/ws/bridge.js

@@ -10,6 +10,8 @@ function clamp(n, lo, hi, def) {
   return Math.max(lo, Math.min(hi, Math.round(n)));
 }
 
+const ATTACH_TIMEOUT_MS = 15000;
+
 function bindWs(ws, deps) {
   const { openAttach, verifyToken, isValidSession = () => true, runAction = () => false, countClients = () => 0, defaults = {}, onAttach = () => {} } = deps;
   let pty = null;
@@ -17,10 +19,31 @@ function bindWs(ws, deps) {
   let session = null;
 
   function fail(code, reason) {
+    // Si spegne anche la scadenza pre-attach: un frame rifiutato (token o
+    // handshake non validi) chiude gia' il socket, e lasciare il timer vivo
+    // fino al close event tiene in piedi un handle senza scopo.
+    clearAttachTimer();
     try { ws.send(JSON.stringify({ type: 'error', reason })); } catch (_) {}
     try { ws.close(code, reason); } catch (_) {}
   }
 
+  // L'upgrade viene accettato prima dell'autenticazione: il token arriva nel
+  // primo frame. Senza una scadenza un socket che non manda MAI l'attach resta
+  // aperto e non autenticato a tempo indefinito, e il costo si moltiplica su
+  // ogni listener che serve l'app. La finestra e' generosa (un client reale
+  // manda l'attach all'apertura) ma non infinita.
+  const attachTimeoutMs = Number.isFinite(defaults.attachTimeoutMs)
+    ? Math.max(1000, defaults.attachTimeoutMs) : ATTACH_TIMEOUT_MS;
+  let attachTimer = setTimeout(() => {
+    attachTimer = null;
+    if (!attached) fail(4408, 'attach timeout');
+  }, attachTimeoutMs);
+  if (typeof attachTimer.unref === 'function') attachTimer.unref();
+  // Dichiarazione (hoisted): `fail` la chiama ed e' definita piu' sopra.
+  function clearAttachTimer() {
+    if (attachTimer) { clearTimeout(attachTimer); attachTimer = null; }
+  }
+
   function onMessage(data, isBinary) {
     if (!attached) {
       if (isBinary) return fail(1002, 'binary before attach');
@@ -30,6 +53,7 @@ function bindWs(ws, deps) {
       if (!verifyToken(msg.token)) return fail(4401, 'bad token');
       if (!isValidSession(msg.session)) return fail(4404, 'no such session');
       attached = true;
+      clearAttachTimer();
       session = msg.session;
       onAttach(session, ws);
       // Resize default: when nobody else is attached, drive the session size so a
@@ -83,7 +107,7 @@ function bindWs(ws, deps) {
   }
 
   ws.on('message', onMessage);
-  ws.on('close', () => { if (pty) pty.kill(); pty = null; });
-  ws.on('error', () => { if (pty) pty.kill(); pty = null; });
+  ws.on('close', () => { clearAttachTimer(); if (pty) pty.kill(); pty = null; });
+  ws.on('error', () => { clearAttachTimer(); if (pty) pty.kill(); pty = null; });
 }
 module.exports = { bindWs, clamp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.8.46",
+  "version": "0.8.48",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {