@mmmbuto/nexuscrew 0.9.40 → 0.9.41

package/lib/fleet/runtime.js

@@ -19,6 +19,7 @@ const {
 } = require('./definitions.js');
 const {
   describeManaged, resolveManagedEngine, discoverOllamaModels, discoverPiModels, extraModelsFrom,
+  knownMcpServerNames,
 } = require('./managed.js');
 const { sharedProbe: defaultEndpointProbe } = require('./endpoint-probe.js');
 const {
@@ -28,6 +29,56 @@ const {
   redactSecrets, sanitizeEarlyDiagnostic,
 } = require('./launch.js');
 const { waitDeliveryReport, actionRequiredFor, vlPaneReadiness } = require('./prompt-delivery.js');
+const { scriviGenerazione } = require('../files/activity.js');
+
+// Insieme MCP MATERIALIZZATO della cella — le chiavi del file che
+// writeCellMcpConfig (managed.js) scrive PRIMA dello spawn. Un server non
+// concesso non esiste per il launch, quindi non e' atteso dal gate.
+const MCP_BUDGET_DEFAULT_MS = 20000; // tetto approvato per il gate MCP
+
+function cellMcpExpectedServers(home, cellId) {
+  const fs = require('node:fs');
+  try {
+    const p = path.join(home, '.nexuscrew', 'cell-mcp', `${cellId}.json`);
+    const st = fs.lstatSync(p);
+    if (st.isSymbolicLink() || !st.isFile()) return [];
+    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const servers = parsed && typeof parsed === 'object' && parsed.mcpServers
+      && typeof parsed.mcpServers === 'object' && !Array.isArray(parsed.mcpServers)
+      ? parsed.mcpServers : null;
+    return servers ? Object.keys(servers).sort() : [];
+  } catch (_) { return []; }
+}
+
+// Celle claude LEGACY (nessun materializzato cell-mcp): l'atteso e' la config
+// nota al client (le tre sorgenti di `knownMcpServerNames`) meno cio' che la
+// cella nega con `cell.mcp`. RESIDUO DICHIARATO: plugin, connettori e
+// configurazione gestita di sistema non sono enumerabili e restano fuori
+// dall'atteso — il gate copre cio' che e' enumerabile, mai promette il totale.
+function legacyMcpExpectedServers(home, cwd, cell) {
+  const noti = [...(knownMcpServerNames(home, cwd) || [])];
+  if (!noti.length) return [];
+  const voluti = cell && Array.isArray(cell.mcp) ? cell.mcp : null;
+  if (voluti === null) return [...noti].sort();
+  const concessi = new Set(voluti.filter((n) => typeof n === 'string'));
+  return [...noti].filter((n) => concessi.has(n)).sort();
+}
+
+// Payload readiness per il supervisore: cwd reale della cella + attese + tetto
+// MCP. Priorita' all'insieme MATERIALIZZATO (cell-mcp); per le claude legacy
+// ricade sulla config nota meno i negati. undefined quando la cella non ha
+// server attesi (niente gate: consegna come kimi, che da 0.8.47 non ha gate).
+function buildMcpReadinessPayload(cell, realCwd, home, cfg) {
+  const expectedServers = cellMcpExpectedServers(home, cell.id).length
+    ? cellMcpExpectedServers(home, cell.id)
+    : legacyMcpExpectedServers(home, realCwd, cell);
+  if (!expectedServers.length) return undefined;
+  return {
+    cwd: realCwd,
+    expectedServers,
+    budgetMs: Math.max(0, Math.min(120000, Number(cfg && cfg.mcpReadyBudgetMs) || MCP_BUDGET_DEFAULT_MS)),
+  };
+}
 
 // TTL della cache status (ms): scaduto, status rilegge tmux + defs da disco.
 const STATUS_TTL_MS = 2000;
@@ -241,7 +292,16 @@ function createBuiltinRuntime(ctx) {
     if (!engine) throw httpError(400, `engine dangling per cella ${cellId}: ${cell.engine}`);
     let launchEngine = engine;
     if (engine.managed) {
-      const resolved = resolveManagedEngine(engine, cell, { ...cfg, home, extraModels: extraModelsFrom(defs), capabilityProfiles: defs.capabilityProfiles || null });
+      // Generazione del lancio: identifica QUESTA partenza della cella. Uno
+      // stato di attivita' che ne porta un'altra appartiene a un lancio
+      // precedente e viene scartato — una cella riavviata non eredita il
+      // «lavora» di prima.
+      const generazione = crypto.randomBytes(8).toString('hex');
+      const resolved = resolveManagedEngine(engine, cell, {
+        ...cfg, home, extraModels: extraModelsFrom(defs),
+        capabilityProfiles: defs.capabilityProfiles || null,
+        activityGeneration: generazione,
+      });
       // Il materializzatore MCP per cella e' FAIL-CLOSED: se il file per cella
       // non si scrive, la cella non parte — mai con la superficie intera dove
       // l'operatore l'ha ristretta.
@@ -253,6 +313,11 @@ function createBuiltinRuntime(ctx) {
         throw httpError(400, `engine managed non configurato (${engine.id}): ${resolved.reason}`, null, { phase: 'preflight', code });
       }
       launchEngine = resolved.engine;
+      // La generazione si scrive PRIMA che il client parta: gli hook possono
+      // scattare appena il processo e' vivo, e uno stato che arrivasse prima
+      // della generazione verrebbe scartato come se fosse di un lancio
+      // precedente. Solo per le celle che hanno davvero gli hook.
+      if (resolved.activityDir) scriviGenerazione(resolved.activityDir, generazione);
       // A vl cell whose runtime cannot hold the per-cell prompt
       // (VL_SYSTEM_APPEND_FILE, 0.3.1+) DEGRADES by declaring it — same
       // shape as readinessDegraded: the cell starts without its own identity
@@ -342,12 +407,17 @@ function createBuiltinRuntime(ctx) {
             tmuxSession: cell.tmuxSession,
             prompt: cell.prompt,
             readyMs: Math.max(0, Math.min(30000, Number(cfg.sendKeysReadyMs) || readyMs)),
-            // Solo gli engine managed Kimi (kimi.native / claude.kimi-code) hanno
-            // la delivery classificata at-most-once ai restart; gli engine custom
-            // Send-keys conservano il reinject legacy senza Enter (0.8.47).
-            client: engine.managed && engine.managed.client === 'kimi' ? 'kimi'
-              : (engine.managed && engine.managed.provider === 'kimi-code' ? 'claude' : ''),
+            // kimi.* e TUTTE le claude.* hanno la delivery classificata
+            // at-most-once ai restart; gli engine custom send-keys conservano
+            // il reinject legacy senza Enter (0.8.47).
+            client: engine.managed && (engine.managed.client === 'kimi' || engine.managed.client === 'claude')
+              ? engine.managed.client : '',
             readyWaitMs: Math.max(0, Math.min(120000, Number(cfg.bootstrapReadyWaitMs) || 15000)),
+            // Gate readiness MCP solo per le claude.* (budget composto col
+            // readyWaitMs: tetto MCP dal launch, avvio degradato visibile).
+            ...(engine.managed && engine.managed.client === 'claude' ? {
+              mcpReadiness: buildMcpReadinessPayload(cell, realCwd, home, cfg),
+            } : {}),
           },
         } : {}),
       });
@@ -557,14 +627,20 @@ function createBuiltinRuntime(ctx) {
     // Paste SENZA Enter, contratto invariato —), target %N esatto.
     let prompt = null;
     let actionRequired = null;
+    let mcpDegraded = null;
     if (launchEngine.promptMode === 'send-keys' && cell.prompt) {
       const managedClient = engine.managed && typeof engine.managed.client === 'string' ? engine.managed.client : '';
       const managedProvider = engine.managed && typeof engine.managed.provider === 'string' ? engine.managed.provider : '';
-      const classified = managedClient === 'kimi' || managedProvider === 'kimi-code';
+      const classified = managedClient === 'kimi' || managedClient === 'claude';
       if (classified) {
         const readyWaitMs = Math.max(0, Math.min(120000, Number(cfg.bootstrapReadyWaitMs) || 15000));
+        // Budget unico composto — il report copre anche il tetto MCP del
+        // gate (l'attesa MCP consuma lo stesso orologio del launch).
+        const mcpBudgetMs = managedClient === 'claude'
+          ? Math.max(0, Math.min(120000, Number(cfg.mcpReadyBudgetMs) || MCP_BUDGET_DEFAULT_MS))
+          : 0;
         const reportWaitMs = Math.max(100, Math.min(150000,
-          (Number(cfg.sendKeysReadyMs) || readyMs) + readyWaitMs + 2000));
+          (Number(cfg.sendKeysReadyMs) || readyMs) + readyWaitMs + mcpBudgetMs + 2000));
         const report = await waitDeliveryReport(tmuxBin,
           paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`,
           { env: minimalEnv(), timeoutMs: reportWaitMs });
@@ -576,8 +652,17 @@ function createBuiltinRuntime(ctx) {
           delivered: delivery.delivered,
           state: delivery.state,
           reason: delivery.reason,
+          ...(delivery.mcp ? { mcp: delivery.mcp } : {}),
         };
         actionRequired = actionRequiredFor(managedClient, managedProvider, delivery);
+        // Avvio degradato visibile: l'elenco bounded dei server MCP non pronti
+        // sale alla UI con il flag esistente readinessDegraded.
+        if (delivery.mcp && delivery.mcp.state === 'degraded') {
+          mcpDegraded = {
+            failed: Array.isArray(delivery.mcp.failed) ? delivery.mcp.failed : [],
+            pending: Array.isArray(delivery.mcp.pending) ? delivery.mcp.pending : [],
+          };
+        }
       } else {
         const target = paneId.startsWith('%') ? paneId : `=${cell.tmuxSession}`;
         prompt = await injectPrompt(tmuxBin, cell.tmuxSession, cell.prompt, {
@@ -593,6 +678,7 @@ function createBuiltinRuntime(ctx) {
       ok: true, cell: cellId, session: cell.tmuxSession, prompt,
       ...(actionRequired ? { actionRequired } : {}),
       ...(readinessDegraded ? { readinessDegraded: true } : {}),
+      ...(mcpDegraded ? { readinessDegraded: true, mcpDegraded } : {}),
       // Per-cell prompt not delivered to a vl cell (old runtime or
       // unwritable file). Strict boolean like readinessDegraded: the
       // payload may come from a federated node and the text is local i18n.
@@ -630,4 +716,4 @@ function createBuiltinRuntime(ctx) {
   };
 }
 
-module.exports = { createBuiltinRuntime, findCell, findEngine, identityLaunchRefusal, STATUS_TTL_MS };
+module.exports = { createBuiltinRuntime, findCell, findEngine, identityLaunchRefusal, STATUS_TTL_MS, buildMcpReadinessPayload, cellMcpExpectedServers };

package/lib/notify/ask-relay.js

@@ -14,23 +14,66 @@
 // refused locally until verification resolves the attempt.
 
 const crypto = require('node:crypto');
+const { probeReverseSlot } = require('../nodes/reverse-slot-proof.js');
 const IDLE_MS = 15000;
 
-function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = () => {} } = {}) {
+function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = () => {}, probeReverseSlotImpl = probeReverseSlot } = {}) {
   // (ownerId|askId|requestId) -> {state: 'sent'|'committed'|'failed'|'uncertain', requestId}
   const attempts = new Map();
 
   function requestId() { return crypto.randomUUID(); }
 
-  function resolveOwner(ownerId) {
+  // Risoluzione del produttore: peer OUTBOUND (canale proprio, come sempre)
+  // oppure peer INBOUND condiviso con consenso eventi+risposta e slot reverse
+  // attivo. Per gli inbound la porta dello slot DEVE essere verificata con la
+  // stessa sonda dei terminali (secret del peer + instanceId atteso): nessun
+  // fallback sulla localPort senza proof.
+  function candidateOwner(ownerId) {
     const store = loadStore();
     if (!store) return null;
-    return (store.nodes || []).find((n) => n && n.direction === 'outbound'
-      && n.nodeId === ownerId && n.token && n.localPort) || null;
+    const nodes = store.nodes || [];
+    const out = nodes.find((n) => n && n.direction === 'outbound'
+      && n.nodeId === ownerId && n.token && n.localPort);
+    if (out) return { node: out, forwardPort: out.localPort, forwardToken: out.token, kind: 'outbound' };
+    const inbound = nodes.find((n) => n && n.direction === 'inbound'
+      && n.shared === true && n.nodeId === ownerId
+      && (n.token || n.acceptToken)
+      && n.askReplyAccess === true && n.eventsAccess === true
+      && n.cellVisibility !== 'none');
+    if (!inbound) return null;
+    const forwardToken = inbound.token || inbound.acceptToken;
+    const pool = inbound.reversePool;
+    const slot = pool && Array.isArray(pool.slots) ? pool.slots[pool.activeSlot] : null;
+    if (!slot || !Number.isInteger(slot.port)) {
+      return { node: inbound, forwardPort: null, forwardToken, kind: 'inbound-unverified' };
+    }
+    return { node: inbound, forwardPort: slot.port, forwardToken, kind: 'inbound' };
+  }
+
+  function ownerUrl(port, path) {
+    return `http://127.0.0.1:${port}/federation/route/_/${path.replace(/^\//, '')}`;
   }
 
-  function ownerUrl(peer, path) {
-    return `http://127.0.0.1:${peer.localPort}/federation/route/_/${path.replace(/^\//, '')}`;
+  // Preflight del canale reverse per un peer inbound: rifiuto NETTO se lo slot
+  // non e' verificato (non e' un esito incerto: il forward non e' mai partito).
+  async function verifyInboundChannel(candidate) {
+    const { node, forwardPort } = candidate;
+    const pool = node.reversePool;
+    const slot = pool && Array.isArray(pool.slots) ? pool.slots[pool.activeSlot] : null;
+    const proof = await probeReverseSlotImpl({
+      port: forwardPort, secret: node.token,
+      expected: {
+        remotePort: forwardPort,
+        generation: pool && Number.isInteger(pool.activeGeneration) ? pool.activeGeneration : undefined,
+        instanceId: node.nodeId,
+      },
+    });
+    if (proof && proof.owned === true) return { ok: true };
+    return {
+      ok: false, code: 404,
+      error: 'canale reverse non verificato: risposta non inoltrata',
+      reason: 'reverse-slot-unverified',
+    };
   }
 
   function attemptKey(ownerId, askId, rid) { return `${ownerId}|${askId}|${rid}`; }
@@ -47,16 +90,35 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
     return statusFor(ownerId, askId).some((a) => a.state === 'uncertain');
   }
 
+  // Il blocco precedente rifiuta il nuovo requestId PRIMA di creare la sua
+  // ricevuta: la sola verifica possibile e' sull'ID originale ancora 'sent'
+  // (se esiste), altrimenti resta solo la riconciliazione con l'owner.
+  function originalSentRequestId(ownerId, askId, excludeRid) {
+    const sent = statusFor(ownerId, askId)
+      .filter((a) => (a.state === 'sent' || a.state === 'uncertain') && a.requestId !== excludeRid);
+    return sent.length ? sent[sent.length - 1].requestId : null;
+  }
+
   async function relayAnswer({ ownerId, askId, text, rid: providedRid } = {}) {
     if (!ownerId || !askId || typeof text !== 'string' || !text.trim()) {
       return { ok: false, code: 400, error: 'ownerId, askId e text richiesti' };
     }
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     // Local reconciliation FIRST: an uncertain attempt on this ask must be
     // verified before any new paste leaves this node.
     if (isUncertain(ownerId, askId)) {
-      return { ok: false, code: 409, error: 'esito incerto: verifica lo stato prima di rispondere', reason: 'uncertain', uncertain: true };
+      // L'ID originale e' quello verificabile: il nuovo invio non e' mai partito.
+      return { ok: false, code: 409, error: 'esito incerto: verifica lo stato prima di rispondere', reason: 'uncertain', uncertain: true,
+        originalRequestId: originalSentRequestId(ownerId, askId) };
     }
     const rid = providedRid || requestId();
     const key = attemptKey(ownerId, askId, rid);
@@ -65,10 +127,10 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), IDLE_MS);
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}/answer`), {
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}/answer`), {
         method: 'POST',
         headers: {
-          authorization: `Bearer ${peer.token}`,
+          authorization: `Bearer ${candidate.forwardToken}`,
           'content-type': 'application/json',
           'x-nexuscrew-visited': store.nodeId,
         },
@@ -86,6 +148,13 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
       // could have pasted (timeout-ish) parks as uncertain, never retried.
       if (r.status === 409) {
         if (entry) entry.state = body.reason === 'delivery-unknown-block' ? 'uncertain' : 'failed';
+        if (body.reason === 'delivery-unknown-block') {
+          // Stesso contratto del ramo 502: la UI riceve 200+uncertain e non
+          // ripete mai il paste. La verifica possibile e' sull'ID originale.
+          return { ok: false, code: 200, uncertain: true, reason: body.reason,
+            originalRequestId: originalSentRequestId(ownerId, askId, rid), requestId: rid,
+            error: 'esito incerto: bloccato da un invio precedente' };
+        }
         return { ok: false, code: 409, error: body.error || 'conflict', reason: body.reason };
       }
       if (r.status === 502) {
@@ -108,13 +177,21 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
 
   // Remote dismiss: same resolution rules as the answer (DELETE on the owner).
   async function relayDismiss({ ownerId, askId } = {}) {
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     const store = loadStore();
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}`), {
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}`), {
         method: 'DELETE',
-        headers: { authorization: `Bearer ${peer.token}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
+        headers: { authorization: `Bearer ${candidate.forwardToken}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
       });
       const body = await r.json().catch(() => ({}));
       if (!r.ok) return { ok: false, code: r.status, error: body.error || `HTTP ${r.status}` };
@@ -123,12 +200,20 @@ function createAskRelay({ loadStore, now = Date.now, fetchImpl = fetch, log = ()
   }
 
   async function verifyStatus({ ownerId, askId, requestId: rid }) {
-    const peer = resolveOwner(ownerId);
-    if (!peer) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati' };
+    const candidate = candidateOwner(ownerId);
+    if (!candidate) return { ok: false, code: 404, error: 'owner non tra i peer autorizzati', reason: 'owner-unknown' };
+    if (candidate.kind === 'inbound-unverified') {
+      return { ok: false, code: 404, error: 'canale reverse non verificato: risposta non inoltrata', reason: 'reverse-slot-unverified' };
+    }
+    if (candidate.kind === 'inbound') {
+      const gate = await verifyInboundChannel(candidate);
+      if (!gate.ok) return { ok: false, code: gate.code, error: gate.error, reason: gate.reason };
+    }
+    const peer = candidate.node;
     const store = loadStore();
     try {
-      const r = await fetchImpl(ownerUrl(peer, `/event-feed/asks/${askId}/requests/${rid}`), {
-        headers: { authorization: `Bearer ${peer.token}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
+      const r = await fetchImpl(ownerUrl(candidate.forwardPort, `/event-feed/asks/${askId}/requests/${rid}`), {
+        headers: { authorization: `Bearer ${candidate.forwardToken}`, 'x-nexuscrew-visited': store ? store.nodeId : '' },
       });
       if (!r.ok) return { ok: false, code: r.status };
       const body = await r.json();

package/lib/server.js

@@ -20,6 +20,7 @@ const { requireToken, bearerFrom } = require('./auth/middleware.js');
 const { filesRoutes } = require('./files/routes.js');
 const { createOutboxWatcher } = require('./files/watcher.js');
 const { leggiTelemetria } = require('./files/telemetry.js');
+const { leggiAttivita } = require('./files/activity.js');
 const VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
@@ -993,6 +994,12 @@ function createServer(opts = {}) {
           // Claude via statusline). Null per tutte le altre — assenza
           // legittima, non un trattino: la riga resta com'era.
           telemetry: leggiTelemetria(cfg.filesRoot, s.name),
+          // Stato del turno pubblicato dagli hook della cella: lavora /
+          // ferma / attesa. `null` NON e' «ferma»: e' «non verificato» —
+          // nessun evento entro la finestra, oppure una cella che non ha questo
+          // canale (codex-vl, pi, shell). La UI non deve dedurre «ferma» da un
+          // silenzio: e' esattamente l'errore che il titolo del pane fa oggi.
+          attivita: leggiAttivita(cfg.filesRoot, s.name),
         };
       }));
       res.json({ sessions: enriched });
@@ -1272,6 +1279,12 @@ function createServer(opts = {}) {
       });
     } catch (e) { res.status(500).json({ error: String(e.message || e) }); }
   });
+  // Riconciliazione dopo refresh: gli esiti incerti noti al relay (solo
+  // contatori/ID, mai testo) per ricostruire lo stato «verifica» senza reinvii.
+  api.get('/asks-relay/state', (_req, res) => {
+    try { res.json({ attempts: askRelay.state() }); }
+    catch (e) { res.status(500).json({ error: String(e.message || e) }); }
+  });
   // The client re-emits imported events into the local hub (deliverOnly: the
   // notifier is bypassed on purpose). The alert relay hangs off that same call,
   // so ONLY an imported notify can ring this device, and never through the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.9.40",
+  "version": "0.9.41",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {
@@ -45,15 +45,16 @@
     "express": "^4.21.0",
     "multer": "^2.2.0",
     "qrcode-terminal": "^0.12.0",
+    "smol-toml": "1.9.0",
     "web-push": "^3.6.7",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {
-    "@mmmbuto/node-pty-android-arm64": "^1.1.2",
     "@lydell/node-pty-darwin-arm64": "^1.2.0-beta.14",
     "@lydell/node-pty-darwin-x64": "^1.2.0-beta.14",
     "@lydell/node-pty-linux-arm64": "^1.2.0-beta.12",
-    "@lydell/node-pty-linux-x64": "^1.2.0-beta.12"
+    "@lydell/node-pty-linux-x64": "^1.2.0-beta.12",
+    "@mmmbuto/node-pty-android-arm64": "^1.1.2"
   },
   "engines": {
     "node": ">=18"