@mmmbuto/nexuscrew 0.8.11 → 0.8.13

package/lib/server.js

@@ -9,7 +9,7 @@ const { WebSocketServer } = require('ws');
 const { defaults, loadConfig, assertLoopback, configJsonPath } = require('./config.js');
 const { writeConfigAtomic } = require('./cli/init.js');
 const { listSessions, attachedClients } = require('./tmux/list.js');
-const { runAction, pasteToSession } = require('./tmux/actions.js');
+const { runAction, pasteToSession, submitToSession } = require('./tmux/actions.js');
 const { createSession, killSession, isProtectedSession } = require('./tmux/lifecycle.js');
 const { createPreviewSampler } = require('./tmux/preview.js');
 const { openAttach } = require('./pty/attach.js');
@@ -22,6 +22,7 @@ const VERSION = require('../package.json').version;
 const { transcribe } = require('./voice/transcribe.js');
 const { selectProvider } = require('./fleet/provider.js');
 const { fleetRoutes } = require('./fleet/routes.js');
+const { cellsRoutes } = require('./cells/routes.js');
 const { fsRoutes } = require('./fs/routes.js');
 const nodesStore = require('./nodes/store.js');
 const nodesTunnel = require('./nodes/tunnel.js');
@@ -220,6 +221,14 @@ function createServer(opts = {}) {
     sessionExists: (name) => sessionExists(cfg.tmuxBin, name),
   }));
   api.use('/fleet', fleetRoutes(fleetP, cfg));
+  api.use('/cells', cellsRoutes({
+    fleetP,
+    instanceId: () => (nodesStore.loadStore(nodesPath) || {}).nodeId || null,
+    submit: opts.cellSubmit || ((session, text, meta) => submitToSession(cfg.tmuxBin, session, text, {
+      engine: meta && meta.engine,
+    })),
+    readonly: proxyReadonly,
+  }));
   api.use('/decks', decksRoutes({ cfg, decksPath }));
   api.use('/fs', fsRoutes({ home: os.homedir() }));  // folder-picker del dialog new session
   // /nodes (read-only, per la settings UI B2): stesso formato di `nodes list --json`

package/lib/settings/routes.js

@@ -47,7 +47,7 @@ const nodesStore = require('../nodes/store.js');
 const nodesCmds = require('../nodes/commands.js');
 const nodesTunnel = require('../nodes/tunnel.js');
 const peering = require('../nodes/peering.js');
-const { probeHealth } = require('../proxy/federation.js');
+const { probeHealth, waitForHealthyPeer } = 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');
@@ -822,9 +822,10 @@ function settingsRoutes(deps = {}) {
       if (!started.started && started.reason !== 'already running') {
         throw new Error(started.reason || 'avvio SSH fallito');
       }
-      const ready = await probeHealth({
+      const ready = await waitForHealthyPeer({
         port: node.localPort, token: node.token, expectedInstanceId: node.nodeId,
-        fetchImpl,
+        fetchImpl, attempts: 8, delayMs: 200,
+        ...(typeof seams.pairDelay === 'function' ? { delay: seams.pairDelay } : {}),
       });
       if (!ready || ready.status !== 'healthy') {
         const diagnosis = (seams.readTunnelDiagnostic || nodesTunnel.readTunnelDiagnostic)(home, name, node.remotePort);

package/lib/tmux/actions.js

@@ -1,5 +1,10 @@
 'use strict';
 const { execFile } = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { isValidSession } = require('../files/store.js');
 
 // Window/pane navigation must NOT be emulated with client-side prefix keys
 // (it depends on each host's bindings, which may be remapped or broken).
@@ -53,6 +58,7 @@ function runAction(tmuxBin, session, name) {
 }
 
 const MAX_PASTE = 4096;
+const MAX_SUBMIT = 8192;
 
 // true se text contiene control char (codici 0x00-0x1f e 0x7f). Espresso via
 // charCode invece di regex perche' il write-layer corrompe gli escape backslash
@@ -86,4 +92,93 @@ function pasteToSession(tmuxBin, session, text) {
   });
 }
 
-module.exports = { actionArgs, runAction, ACTIONS, pasteArgs, pasteToSession, scrollArgs };
+function submitTextOk(text) {
+  if (typeof text !== 'string' || !text || text.length > MAX_SUBMIT) return false;
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text.charCodeAt(i);
+    if (c === 9 || c === 10 || c === 13) continue;
+    if (c < 32 || c === 127) return false;
+  }
+  return true;
+}
+
+function execTmux(execFileImpl, tmuxBin, args, timeout = 5000) {
+  return new Promise((resolve) => {
+    try {
+      execFileImpl(tmuxBin, args, { timeout }, (err, stdout) => {
+        resolve({ ok: !err, stdout: String(stdout || '') });
+      });
+    } catch (_) { resolve({ ok: false, stdout: '' }); }
+  });
+}
+
+// Consegna un messaggio a un pane esatto e lo sottopone al TUI. Il testo non
+// passa mai in argv: file temporaneo 0600 -> tmux load-buffer -> paste-buffer -p
+// (bracketed paste), poi Enter con una chiamata separata. Il pane id viene
+// risolto prima del paste e verificato di nuovo prima dell'Enter, evitando
+// prefix match e il riuso del solo nome sessione.
+async function submitToSession(tmuxBin, session, text, opts = {}) {
+  if (!isValidSession(session) || !submitTextOk(text)) {
+    return { submitted: false, reason: 'input non valido' };
+  }
+  const execFileImpl = opts.execFileImpl || execFile;
+  const fsImpl = opts.fsImpl || fs;
+  const tmpRoot = opts.tmpdir || os.tmpdir();
+  const delay = typeof opts.delay === 'function'
+    ? opts.delay : (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const codexComposer = /^(?:codex|codex-vl)(?:\.|$)/.test(String(opts.engine || ''));
+  const nonce = (opts.nonce || crypto.randomBytes(8).toString('hex')).replace(/[^a-f0-9]/g, '').slice(0, 32);
+  if (!nonce) return { submitted: false, reason: 'invio non disponibile' };
+  const buffer = `ncmsg-${nonce}`;
+  const tmp = path.join(tmpRoot, `.nexuscrew-message-${nonce}.txt`);
+  let loaded = false;
+  try {
+    fsImpl.writeFileSync(tmp, text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    fsImpl.chmodSync(tmp, 0o600);
+    const pane = await execTmux(execFileImpl, tmuxBin,
+      ['display-message', '-p', '-t', `=${session}:`, '#{pane_id}']);
+    const paneId = pane.stdout.trim();
+    if (!pane.ok || !/^%[0-9]+$/.test(paneId)) {
+      return { submitted: false, reason: 'sessione non raggiungibile' };
+    }
+    const load = await execTmux(execFileImpl, tmuxBin, ['load-buffer', '-b', buffer, tmp]);
+    if (!load.ok) return { submitted: false, reason: 'buffer non disponibile' };
+    loaded = true;
+    const paste = await execTmux(execFileImpl, tmuxBin,
+      ['paste-buffer', '-p', '-t', paneId, '-b', buffer]);
+    if (!paste.ok) return { submitted: false, reason: 'consegna non riuscita' };
+    const paneAlive = async () => {
+      const verify = await execTmux(execFileImpl, tmuxBin,
+        ['display-message', '-p', '-t', paneId, '#{session_name}\t#{pane_dead}\t#{pane_id}']);
+      const [verifiedSession, dead, verifiedPane] = verify.stdout.trim().split('\t');
+      return verify.ok && verifiedSession === session && dead === '0' && verifiedPane === paneId;
+    };
+    // Codex/Codex-VL have a paste-burst window: a too-early Enter can remain
+    // inside the composer. C-e is sent as its own tmux command after the paste,
+    // then the pane is revalidated before the separate Enter. Other clients
+    // still receive a short separation between paste and submit.
+    await delay(codexComposer ? 400 : 150);
+    if (!(await paneAlive())) return { submitted: false, reason: 'sessione terminata durante la consegna' };
+    if (codexComposer) {
+      const flush = await execTmux(execFileImpl, tmuxBin, ['send-keys', '-t', paneId, 'C-e']);
+      if (!flush.ok) return { submitted: false, reason: 'testo consegnato ma flush composer non riuscito' };
+      await delay(300);
+      if (!(await paneAlive())) return { submitted: false, reason: 'sessione terminata durante la consegna' };
+    }
+    const enter = await execTmux(execFileImpl, tmuxBin, ['send-keys', '-t', paneId, 'Enter']);
+    if (!enter.ok) return { submitted: false, reason: 'testo consegnato ma invio non riuscito' };
+    return { submitted: true, reason: codexComposer
+      ? 'bracketed paste + burst flush + Enter separati'
+      : 'bracketed paste + Enter separato' };
+  } catch (_) {
+    return { submitted: false, reason: 'consegna non riuscita' };
+  } finally {
+    if (loaded) await execTmux(execFileImpl, tmuxBin, ['delete-buffer', '-b', buffer]);
+    try { fsImpl.unlinkSync(tmp); } catch (_) { /* cleanup best-effort */ }
+  }
+}
+
+module.exports = {
+  actionArgs, runAction, ACTIONS, pasteArgs, pasteToSession, scrollArgs,
+  submitTextOk, submitToSession, MAX_SUBMIT,
+};

package/lib/tmux/list.js

@@ -17,7 +17,8 @@ function parseSessions(raw) {
         activity: Number(activity) || 0,
         cmd: cmd || '',
       };
-    });
+    })
+    .filter((session) => session.windows > 0);
 }
 
 function listSessions(tmuxBin = 'tmux') {

package/lib/update/core.js

@@ -48,15 +48,42 @@ function compareVersions(a, b) {
 }
 
 function registryVersion(stdout) {
-  const raw = String(stdout || '').trim();
-  let value = raw;
+  const raw = String(stdout || '')
+    .replace(/^\uFEFF/, '')
+    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+    .trim();
+  const candidates = [];
+  const add = (value) => {
+    if (typeof value !== 'string') return;
+    const parsed = parseVersion(value);
+    if (parsed) candidates.push(parsed.raw);
+  };
   try {
     const decoded = JSON.parse(raw);
-    if (typeof decoded === 'string') value = decoded;
-  } catch (_) { /* npm senza --json o output gia' plain */ }
-  const parsed = parseVersion(value);
-  if (!parsed) throw new Error('npm ha restituito una versione non valida');
-  return parsed.raw;
+    if (typeof decoded === 'string') add(decoded);
+    else if (Array.isArray(decoded)) decoded.forEach(add);
+    else if (decoded && typeof decoded === 'object') add(decoded.version);
+  } catch (_) {
+    // npm versions differ in whether --json returns a JSON scalar or a plain
+    // line.  Notices may also precede the value, so inspect complete lines but
+    // never extract a semver from the middle of arbitrary text.
+    for (const line of raw.split(/\r?\n/)) add(line.trim().replace(/^['"]|['"]$/g, ''));
+  }
+  const unique = [...new Set(candidates)];
+  if (unique.length !== 1) throw new Error('npm ha restituito una versione non valida');
+  return unique[0];
+}
+
+function stableRuntimeDir(home) {
+  const dir = path.join(path.resolve(String(home || '')), '.nexuscrew');
+  try {
+    const st = fs.lstatSync(dir);
+    if (!st.isDirectory() || st.isSymbolicLink()) throw new Error('directory runtime NexusCrew non sicura');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  return dir;
 }
 
 function scrubError(error) {
@@ -153,5 +180,5 @@ function writeState(file, value) {
 module.exports = {
   PACKAGE_NAME, VERSION_RE, parseVersion, compareVersions, registryVersion,
   scrubError, pidAlive, readLock, acquireUpdateLock, adoptUpdateLock, releaseUpdateLock,
-  readState, writeState,
+  readState, writeState, stableRuntimeDir,
 };

package/lib/update/manager.js

@@ -6,7 +6,7 @@ const path = require('node:path');
 const { execFile, spawn } = require('node:child_process');
 const {
   PACKAGE_NAME, compareVersions, parseVersion, registryVersion, scrubError, pidAlive, readLock,
-  acquireUpdateLock, releaseUpdateLock, readState, writeState,
+  acquireUpdateLock, releaseUpdateLock, readState, writeState, stableRuntimeDir,
 } = require('./core.js');
 
 const DEFAULT_INITIAL_DELAY_MS = 60 * 1000;
@@ -24,10 +24,11 @@ function isNewer(candidate, current) {
   try { return compareVersions(candidate, current) > 0; } catch (_) { return false; }
 }
 
-function lookupLatestNpm({ execFileImpl = execFile, timeoutMs = 20_000 } = {}) {
+function lookupLatestNpm({ execFileImpl = execFile, timeoutMs = 20_000, home = os.homedir(), cwd } = {}) {
   return new Promise((resolve, reject) => {
     execFileImpl('npm', ['view', `${PACKAGE_NAME}@latest`, 'version', '--json'], {
       encoding: 'utf8', timeout: timeoutMs, maxBuffer: 64 * 1024,
+      cwd: cwd || stableRuntimeDir(home),
     }, (error, stdout) => {
       if (error) return reject(error);
       try { resolve(registryVersion(stdout)); } catch (e) { reject(e); }
@@ -42,6 +43,7 @@ function createNpmUpdater(opts = {}) {
   const logPath = opts.logPath || path.join(home, '.nexuscrew', 'npm-update.log');
   const lockPath = opts.lockPath || path.join(home, '.nexuscrew', 'npm-update.lock');
   const runnerPath = opts.runnerPath || path.join(__dirname, 'runner.js');
+  const workDir = opts.cwd || stableRuntimeDir(home);
   const supported = opts.supported === undefined ? isGlobalInstall(opts.packageRoot) : !!opts.supported;
   const readonly = opts.readonly === true;
   const lookupLatest = opts.lookupLatest || (() => lookupLatestNpm(opts));
@@ -135,7 +137,8 @@ function createNpmUpdater(opts = {}) {
           process.execPath, ...runnerArgs]
         : runnerArgs;
       child = spawnImpl(bin, argv, {
-        detached: true, stdio: ['ignore', fd, fd], env: { ...process.env, NEXUSCREW_UPDATE_RUNNER: '1' },
+        detached: true, stdio: ['ignore', fd, fd], cwd: workDir,
+        env: { ...process.env, NEXUSCREW_UPDATE_RUNNER: '1' },
       });
     } catch (e) {
       releaseUpdateLock(lockPath, reservation.token);

package/lib/update/runner.js

@@ -7,6 +7,7 @@ const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 const {
   PACKAGE_NAME, parseVersion, scrubError, pidAlive, adoptUpdateLock, releaseUpdateLock, readState, writeState,
+  stableRuntimeDir,
 } = require('./core.js');
 
 function args(argv) {
@@ -69,6 +70,7 @@ async function runUpdate(opts = {}) {
   if (!parseVersion(version)) throw new Error('versione update non valida');
   const home = opts.home || os.homedir();
   const statusPath = opts.statusPath || path.join(home, '.nexuscrew', 'npm-update.json');
+  const workDir = opts.cwd || stableRuntimeDir(home);
   const execImpl = opts.execImpl || execFileSync;
   const readInstalledVersion = opts.readInstalledVersion || (() => {
     const p = path.resolve(__dirname, '..', '..', 'package.json');
@@ -76,7 +78,9 @@ async function runUpdate(opts = {}) {
   });
   const preflightImpl = opts.preflightImpl || (({ version: expectedVersion = version } = {}) => {
     const bin = path.resolve(__dirname, '..', '..', 'bin', 'nexuscrew.js');
-    const output = execFileSync(process.execPath, [bin, 'version'], { encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const output = execFileSync(process.execPath, [bin, 'version'], {
+      encoding: 'utf8', timeout: 20_000, stdio: ['ignore', 'pipe', 'pipe'], cwd: workDir,
+    });
     if (String(output || '').trim() !== expectedVersion) throw new Error(`preflight CLI fallito: attesa ${expectedVersion}`);
     return true;
   });
@@ -96,7 +100,7 @@ async function runUpdate(opts = {}) {
   try {
     writeState(statusPath, { ...previous, phase: 'installing', targetVersion: version, updaterPid: process.pid, lastError: '' });
     execImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${version}`, '--no-audit', '--no-fund'], {
-      stdio: 'inherit', timeout: 5 * 60 * 1000,
+      stdio: 'inherit', timeout: 5 * 60 * 1000, cwd: workDir,
     });
     const installed = String(readInstalledVersion() || '');
     if (installed !== version) throw new Error(`verifica installazione fallita: attesa ${version}, trovata ${installed || 'sconosciuta'}`);
@@ -114,7 +118,7 @@ async function runUpdate(opts = {}) {
     if (installedNew && parseVersion(previousVersion) && previousVersion !== version) {
       try {
         execImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${previousVersion}`, '--no-audit', '--no-fund'], {
-          stdio: 'inherit', timeout: 5 * 60 * 1000,
+          stdio: 'inherit', timeout: 5 * 60 * 1000, cwd: workDir,
         });
         if (String(readInstalledVersion() || '') !== previousVersion) throw new Error(`rollback verify: attesa ${previousVersion}`);
         await preflightImpl({ version: previousVersion, home, rollback: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscrew",
-  "version": "0.8.11",
+  "version": "0.8.13",
   "description": "Faithful browser tmux client — attach to live sessions over a real PTY, localhost-only, mobile-easy",
   "main": "lib/server.js",
   "bin": {
@@ -20,7 +20,7 @@
     "start": "node bin/nexuscrew.js serve",
     "dev": "node bin/nexuscrew.js serve",
     "build": "cd frontend && npm install && npm run build && cd ..",
-    "test": "node tests/run-isolated.js"
+    "test": "node tests/run-isolated.js && npm --prefix frontend test"
   },
   "dependencies": {
     "express": "^4.21.0",

package/skills/nexuscrew-agent/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: nexuscrew-agent
-description: Use when an AI agent connected to NexusCrew must notify or ask the human, inspect NexusCrew session/fleet status or its own deck membership, read its inbox, deliver a file (report, screenshot, export), send text/input to a tmux session, or recover from tmux send-keys messages that remain unsubmitted or arrive garbled. Prefer the NexusCrew MCP tools nc_notify, nc_ask, nc_status, nc_deck, nc_inbox, and nc_send_file when exposed; use the bundled tmux/file helpers as fallback.
+description: Use when an AI agent connected to NexusCrew must notify or ask the human, inspect runtime or deck context, list authorized Fleet cells, message an exact active cell, read its inbox, deliver a file, or recover from local tmux messages that remain unsubmitted or garbled. Prefer nc_notify, nc_ask, nc_status, nc_deck, nc_cells, nc_send_cell, nc_inbox, and nc_send_file; use bundled tmux/file helpers only as a declared compatibility fallback.
 ---
 
 # NexusCrew Agent I/O
 
-Use the [NexusCrew](https://github.com/DioNanos/nexuscrew) MCP bridge for communication with the human and read-only runtime status. Use the bundled helpers for direct tmux messaging or as a compatibility fallback.
+Use the [NexusCrew](https://github.com/DioNanos/nexuscrew) MCP bridge for communication with the human, read-only runtime discovery, and authenticated delivery to active Fleet cells. Use the bundled helpers only for same-host tmux compatibility fallbacks.
 
 ## MCP bridge (preferred)
 
@@ -17,6 +17,8 @@ When the client exposes the NexusCrew MCP server, use these tools directly:
 | Ask for a decision without blocking the agent | `nc_ask` |
 | Inspect live tmux sessions and fleet cells | `nc_status` |
 | Read the caller's deck name(s) and member cells/tmux sessions | `nc_deck` |
+| List every authorized owner-qualified Fleet cell | `nc_cells` |
+| Submit a bounded message to an exact active Fleet cell | `nc_send_cell` |
 | List files received for the current session | `nc_inbox` |
 | Deliver an absolute file path under the user's home | `nc_send_file` |
 
@@ -26,7 +28,8 @@ Apply these rules:
 - Never include access tokens, credentials, private keys, push subscriptions, or other secrets in a notification, ask, file caption, or tool result.
 - Treat `nc_ask` as non-blocking: it returns an ask ID immediately. Continue safe independent work or wait normally; the human response arrives in the originating tmux session with a `[human reply · ask#<id>]` prefix by default.
 - Use `nc_status` instead of scraping NexusCrew state files. Use `nc_deck` instead of reading `decks.json`: it returns every local or authorized shared-owner deck containing the caller, preserves visual member order, identifies each deck and member by stable owner ID, includes viewer-valid Hydra routes, and reports `cell: null` when no managed Fleet match is available.
-- Treat `nc_deck` as discovery, not authorization to contact every member. Use the verified tmux-messaging flow below for actual delivery and confirm submission visually.
+- Use `nc_cells` immediately before cross-cell delivery. Select its exact owner-qualified `id`; require `canReceive: true`; never guess a duplicate name or stale route.
+- Use `nc_send_cell {target, message}` for actual Fleet-cell delivery. `submitted` confirms bracketed paste plus Enter only, never task acceptance or completion. Inactive targets are not queued.
 - Use `nc_inbox` instead of guessing an inbox path when the tool is available.
 - Pass `nc_send_file` an existing absolute regular-file path below the user's home. Let NexusCrew choose and sanitize the outbox name.
 - Do not treat an MCP notification as a substitute for the final response required by the active client.
@@ -50,6 +53,10 @@ Don't hand-craft the path from a guessed session name — use `nc-deliver`, or d
 
 ## Sending text to a tmux session
 
+For an active managed Fleet cell, prefer `nc_cells` followed by `nc_send_cell`.
+The helper below is a same-host fallback for older NexusCrew runtimes or
+non-Fleet sessions; it must not bypass federation visibility or routing ACLs.
+
 `tmux send-keys 'msg' Enter` is **not** reliable: a TUI's paste-burst detector swallows the Enter and the message just sits in the composer, while exit code is still 0. Use the helper:
 
 ```bash
@@ -72,6 +79,8 @@ tmux capture-pane -t <session> -p | tail -8   # see the text / a running state
 | Ask the human without blocking | `nc_ask` |
 | Inspect NexusCrew runtime state | `nc_status` |
 | Discover this session's deck neighbours | `nc_deck` |
+| Discover authorized cells across nodes | `nc_cells` |
+| Submit to an exact active Fleet cell | `nc_send_cell` |
 | Give the human a file | `nc_send_file` or fallback `nc-deliver <file>...` |
 | Read a file the human sent | `nc_inbox` or fallback to the path in the prompt |
 | Send a prompt/command to a session | `nc-send <session> "text"` |
@@ -85,3 +94,5 @@ tmux capture-pane -t <session> -p | tail -8   # see the text / a running state
 - **`tmux` aliased/wrapped by the shell** (e.g. an oh-my-zsh plugin) → the nudge silently fails. Helpers resolve the real binary; in ad-hoc commands use `/usr/bin/tmux` or `command tmux`.
 - **Pasting onto a dirty composer** → text concatenates with whatever was there. Clear it first, or the previous line will merge with yours.
 - **Delivering to a guessed session name** → file lands in an orphan folder with no badge. Use `nc-deliver` (it reads the real session).
+- **Sending to an ambiguous cell name** → call `nc_cells` and use the full owner-qualified ID.
+- **Calling `submitted` a completed task** → it is only a transport receipt; require an explicit result callback.