nio-cat 0.1.1 → 0.3.0

package/bin/nio.js

@@ -4,6 +4,7 @@ const os = require('os');
 const path = require('path');
 const fs = require('fs');
 const crypto = require('crypto');
+const net = require('net');
 const { spawn } = require('child_process');
 const config = require('../src/config');
 const { Hub } = require('../src/hub');
@@ -21,11 +22,11 @@ for (let i = 0; i < argv.length; i++) {
   if (a.startsWith('--')) {
     const [k, v] = a.slice(2).split('=');
     if (v !== undefined) flags[k] = v;
-    else if (['port', 'url', 'app'].includes(k)) flags[k] = argv[++i];
+    else if (['port', 'url', 'app', 'local-port', 'dir'].includes(k)) flags[k] = argv[++i];
     else flags[k] = true;
   } else pos.push(a);
 }
-const cmd = ['start', 'pair', 'doctor', 'reset-token', 'help'].includes(pos[0]) ? pos.shift() : 'start';
+const cmd = ['start', 'pair', 'doctor', 'reset-token', 'help', 'ssh'].includes(pos[0]) ? pos.shift() : 'start';
 
 const c = {
   dim: (s) => `\x1b[2m${s}\x1b[0m`,
@@ -55,6 +56,31 @@ function lanIps() {
     .map((i) => i.address);
 }
 
+function openUrl(target) {
+  try {
+    if (process.platform === 'win32') spawn('cmd', ['/c', 'start', '', target], { stdio: 'ignore', detached: true }).unref();
+    else spawn(process.platform === 'darwin' ? 'open' : 'xdg-open', [target], { stdio: 'ignore', detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Obre el panell al navegador d'aquest ordinador, ja connectat. En un servidor (SSH, sense pantalla) no ho fa.
+function canOpenBrowser() {
+  if (flags['no-open'] || process.env.CI) return false;
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return false;
+  if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  return true;
+}
+
+function openDashboard() {
+  const local = `http://127.0.0.1:${cfg.port}`;
+  const link = pairLink(local, local, cfg.token);
+  if (canOpenBrowser() && openUrl(link)) console.log(`  ${c.dim('Panell:')}   ${local}  ${c.dim('(obert al navegador; --no-open per evitar-ho)')}`);
+  else console.log(`  ${c.dim('Panell:')}   ${link}`);
+}
+
 function showPair(publicUrl) {
   const link = pairLink(flags.app || cfg.app, publicUrl, cfg.token);
   const file = writePairPage(link);
@@ -72,6 +98,76 @@ function showPair(publicUrl) {
   }
 }
 
+
+// nio ssh usuari@servidor: engega nio al servidor (si no hi és), obre un túnel SSH i obre el panell ja connectat.
+const shq = (v) => `'${String(v).replace(/'/g, `'\\''`)}'`;
+function remoteScript(port, dir) {
+  return `set -e
+command -v node >/dev/null 2>&1 || { echo NIO_NO_NODE; exit 0; }
+up() { (exec 3<>/dev/tcp/127.0.0.1/${port}) 2>/dev/null; }
+if ! up; then
+  mkdir -p "$HOME/.nio"
+  if command -v setsid >/dev/null 2>&1; then S=setsid; else S=; fi
+  $S nohup npx --yes nio-cat@latest --no-open --no-tunnel --port ${port} ${dir ? shq(dir) : '"$HOME"'} > "$HOME/.nio/daemon.log" 2>&1 < /dev/null &
+  for i in $(seq 1 80); do up && break; sleep 0.5; done
+  up || { echo NIO_NO_START; tail -n 5 "$HOME/.nio/daemon.log" 2>/dev/null; exit 0; }
+fi
+node -e "console.log('NIO_TOKEN='+require(require('os').homedir()+'/.nio/config.json').token)"
+`;
+}
+function sshBase(target) {
+  const a = ['-o', 'ServerAliveInterval=30'];
+  if (process.platform !== 'win32') a.push('-o', 'ControlMaster=auto', '-o', 'ControlPath=/tmp/nio-%C', '-o', 'ControlPersist=10m');
+  return a;
+}
+function waitPort(port, ms = 15000) {
+  const end = Date.now() + ms;
+  return new Promise((resolve) => {
+    const t = () => {
+      const s = net.connect(port, '127.0.0.1');
+      s.once('connect', () => { s.destroy(); resolve(true); });
+      s.once('error', () => { s.destroy(); Date.now() > end ? resolve(false) : setTimeout(t, 300); });
+    };
+    t();
+  });
+}
+async function sshStart() {
+  const target = pos[0];
+  if (!target || !/^[A-Za-z0-9_][\w.@:\-\[\]]*$/.test(target)) {
+    console.log(`\n  Ús: ${c.b('nio ssh usuari@servidor')} ${c.dim('[--port 7717] [--local-port 7718] [--dir /ruta/al/servidor]')}\n`);
+    process.exit(1);
+  }
+  const rport = Number(flags.port || 7717), lport = Number(flags['local-port'] || 7718);
+  console.log(`\n  ${c.b('nio')} ${c.dim('· connectant amb')} ${target}${c.dim('…')}`);
+  const out = await new Promise((resolve) => {
+    const p = spawn('ssh', [...sshBase(target), '-T', '--', target, 'bash -l -s'], { stdio: ['pipe', 'pipe', 'inherit'] });
+    let buf = '';
+    p.stdout.on('data', (d) => (buf += d));
+    p.on('error', () => resolve({ code: -1, buf }));
+    p.on('close', (code) => resolve({ code, buf }));
+    p.stdin.end(remoteScript(rport, flags.dir));
+  });
+  if (out.code === -1) { console.error(c.warn('\n  No trobo l’ordre ssh en aquest ordinador.\n')); process.exit(1); }
+  if (out.code !== 0 && !out.buf.includes('NIO_TOKEN=')) { console.error(c.warn('\n  No he pogut entrar al servidor per SSH.\n')); process.exit(1); }
+  if (out.buf.includes('NIO_NO_NODE')) { console.error(c.warn('\n  Al servidor falta Node.js 18 o més nou. Instal·la’l i torna-ho a provar.\n')); process.exit(1); }
+  if (out.buf.includes('NIO_NO_START')) { console.error(c.warn('\n  nio no s’ha engegat al servidor:\n') + out.buf.replace('NIO_NO_START', '').trim() + '\n'); process.exit(1); }
+  const token = (out.buf.match(/NIO_TOKEN=(\S+)/) || [])[1];
+  if (!token) { console.error(c.warn('\n  No he pogut llegir la clau del servidor.\n')); process.exit(1); }
+
+  const tun = spawn('ssh', [...sshBase(target), '-N', '-T', '-o', 'ExitOnForwardFailure=yes', '-L', `127.0.0.1:${lport}:127.0.0.1:${rport}`, '--', target], { stdio: ['ignore', 'ignore', 'inherit'] });
+  tun.on('close', () => { console.log(c.warn('\n  S’ha tallat el túnel SSH.\n')); process.exit(0); });
+  const bye = () => { tun.kill(); process.exit(0); };
+  process.on('SIGINT', bye);
+  process.on('SIGTERM', bye);
+  if (!(await waitPort(lport))) { console.error(c.warn(`\n  No puc obrir el port ${lport} en aquest ordinador. Prova amb --local-port 7719.\n`)); tun.kill(); process.exit(1); }
+
+  const local = `http://127.0.0.1:${lport}`, link = pairLink(local, local, token);
+  console.log(`  ${c.ok('✓')} Connectat. nio funciona al servidor i el panell és a ${local}`);
+  if (canOpenBrowser() && openUrl(link)) console.log(`  ${c.dim('Panell obert al navegador.')}`);
+  else console.log(`  ${c.dim('Obre aquest enllaç:')} ${link}`);
+  console.log(c.dim('\n  Deixa aquesta finestra oberta mentre facis servir el servidor. Amb Ctrl+C es tanca el túnel (nio continua al servidor).\n'));
+}
+
 async function start() {
   if (flags.port) cfg.port = Number(flags.port);
   if (flags.app) cfg.app = flags.app;
@@ -94,7 +190,7 @@ async function start() {
   const hub = new Hub(cfg);
   let publicUrl = flags.url || null;
   const host = flags.lan ? '0.0.0.0' : '127.0.0.1';
-  const server = createServer({ cfg, hub, getPublicUrl: () => publicUrl });
+  const server = createServer({ cfg, hub, getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
 
   server.on('error', (e) => {
     if (e.code === 'EADDRINUSE') console.error(c.warn(`\n  El port ${cfg.port} ja el fa servir un altre programa. Tria\'n un altre: nio --port 7718\n`));
@@ -104,6 +200,7 @@ async function start() {
 
   server.listen(cfg.port, host, () => {
     console.log(`  ${c.dim('Local:')}    http://127.0.0.1:${cfg.port}`);
+    openDashboard();
 
     if (flags.lan) {
       const ip = lanIps()[0];
@@ -152,6 +249,9 @@ async function start() {
 
 (async () => {
   switch (cmd) {
+    case 'ssh':
+      await sshStart();
+      break;
     case 'doctor':
       await doctor();
       break;
@@ -177,8 +277,18 @@ async function start() {
     --url <adreça>      Una adreça pública teva (Tailscale o similar)
     --no-tunnel         Només des d'aquest ordinador
     --port <n>          Port local (7717 si no dius res)
+    --no-open           No obris el panell al navegador d'aquest ordinador
     --open              Obre al navegador la pàgina del codi QR
   nio pair              Mostra el codi QR una altra vegada
+
+  nio ssh usuari@servidor   Fes servir nio en un servidor (VPS) per SSH, sense obrir cap port.
+    --port <n>          Port de nio al servidor (7717)
+    --local-port <n>    Port en aquest ordinador (7718)
+    --dir <ruta>        Carpeta del servidor on s'engega (per defecte, la teva carpeta d'inici)
+
+  Servidor amb adreça pública: nio --url https://la-teva-adreça --no-open
+                        Deixa'l sota tmux, pm2 o systemd perquè no s'aturi.
+
   nio doctor            Llista els agents instal·lats
   nio reset-token       Crea una clau nova i desconnecta tots els mòbils
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nio-cat",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
   "license": "MIT",
   "author": "f.cat",

package/src/github.js

@@ -0,0 +1,144 @@
+'use strict';
+// GitHub i git des de l'ordinador: es fa servir el «gh» i el «git» que l'usuari ja té.
+// Cap clau no passa per nio: el token queda on és (gh auth), i res no s'executa amb shell.
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { which } = require('./proc');
+
+function fail(status, message) {
+  const e = new Error(message);
+  e.status = status;
+  return e;
+}
+
+function run(cmd, args, { cwd, timeout = 30000 } = {}) {
+  const bin = which(cmd);
+  if (!bin) return Promise.reject(fail(400, `No trobo «${cmd}» en aquest ordinador`));
+  return new Promise((resolve, reject) => {
+    execFile(
+      bin,
+      args,
+      { cwd, timeout, maxBuffer: 8e6, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GH_PROMPT_DISABLED: '1', NO_COLOR: '1', GH_NO_UPDATE_NOTIFIER: '1' } },
+      (err, stdout, stderr) => {
+        if (err) {
+          const msg = String(stderr || err.message || '').trim().split('\n').filter(Boolean).slice(-3).join(' ');
+          return reject(fail(400, msg || 'L’ordre ha fallat'));
+        }
+        resolve({ stdout: String(stdout), stderr: String(stderr) });
+      }
+    );
+  });
+}
+
+const OWNER = /^(?![.-])[\w.-]{1,60}$/;
+const REPO = /^(?![.-])[\w.-]{1,60}\/(?![.-])[\w.-]{1,100}$/;
+const BRANCH = /^(?!-)[\w./-]{1,80}$/;
+
+async function status() {
+  if (!which('gh')) return { available: false, authed: false };
+  try {
+    await run('gh', ['auth', 'status'], { timeout: 10000 });
+  } catch {
+    return { available: true, authed: false };
+  }
+  let user = '';
+  try {
+    user = (await run('gh', ['api', 'user', '--jq', '.login'], { timeout: 10000 })).stdout.trim();
+  } catch {
+    /* sense nom */
+  }
+  return { available: true, authed: true, user };
+}
+
+async function repos(owner) {
+  const args = ['repo', 'list'];
+  if (owner) {
+    if (!OWNER.test(owner)) throw fail(400, 'Aquest propietari no és vàlid');
+    args.push(owner);
+  }
+  args.push('--limit', '100', '--json', 'nameWithOwner,description,isPrivate,isFork,updatedAt');
+  const { stdout } = await run('gh', args, { timeout: 30000 });
+  let list = [];
+  try {
+    list = JSON.parse(stdout);
+  } catch {
+    /* buit */
+  }
+  return list.map((r) => ({
+    repo: r.nameWithOwner,
+    description: String(r.description || '').slice(0, 160),
+    private: !!r.isPrivate,
+    fork: !!r.isFork,
+    updated: r.updatedAt,
+  }));
+}
+
+async function clone(cfg, repo) {
+  repo = String(repo || '').trim();
+  if (!REPO.test(repo)) throw fail(400, 'Aquest repositori no és vàlid');
+  const base = cfg.roots[0];
+  if (!base) throw fail(400, 'No hi ha cap carpeta compartida on clonar-lo');
+  const target = path.join(base, repo.split('/')[1]);
+  if (!target.startsWith(base + path.sep)) throw fail(400, 'Aquest nom de carpeta no és vàlid');
+  if (fs.existsSync(target)) {
+    if (fs.existsSync(path.join(target, '.git'))) return { path: target, existed: true };
+    throw fail(409, `Ja hi ha una carpeta «${path.basename(target)}» que no és git`);
+  }
+  await run('gh', ['repo', 'clone', repo, target], { timeout: 600000 });
+  return { path: target, existed: false };
+}
+
+async function gitInfo(cwd) {
+  try {
+    await run('git', ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 10000 });
+  } catch {
+    return { repo: false };
+  }
+  const out = async (args) => {
+    try {
+      return (await run('git', args, { cwd, timeout: 15000 })).stdout.trim();
+    } catch {
+      return '';
+    }
+  };
+  const branch = (await out(['rev-parse', '--abbrev-ref', 'HEAD'])) || 'HEAD';
+  const raw = await out(['status', '--porcelain=v1']);
+  const files = raw ? raw.split('\n').slice(0, 200).map((l) => ({ status: l.slice(0, 2).trim() || '?', path: l.slice(3) })) : [];
+  const stat = await out(['diff', '--shortstat', 'HEAD']);
+  const remote = (await out(['remote'])).split('\n').filter(Boolean)[0] || '';
+  const ahead = remote ? Number(await out(['rev-list', '--count', '@{u}..HEAD'])) || 0 : 0;
+  const gh = await status();
+  return { repo: true, branch, files, stat, remote, ahead, defaultBranch: branch === 'main' || branch === 'master', gh };
+}
+
+async function commit(cwd, { message, branch }) {
+  message = String(message || '').trim().slice(0, 500);
+  if (!message) throw fail(400, 'Escriu un missatge per al commit');
+  if (branch) {
+    branch = String(branch).trim();
+    if (!BRANCH.test(branch)) throw fail(400, 'Aquest nom de branca no és vàlid');
+    await run('git', ['checkout', '-b', branch], { cwd });
+  }
+  await run('git', ['add', '-A'], { cwd });
+  const r = await run('git', ['commit', '-m', message], { cwd, timeout: 60000 });
+  return { ok: true, summary: r.stdout.trim().split('\n')[0] || 'Fet' };
+}
+
+async function pr(cwd, { title, body }) {
+  const info = await gitInfo(cwd);
+  if (!info.repo) throw fail(400, 'Aquesta carpeta no és un repositori git');
+  if (info.defaultBranch) throw fail(400, 'Ets a la branca principal. Fes el commit en una branca nova per poder crear el PR.');
+  if (!info.remote) throw fail(400, 'Aquest repositori no té cap remot (origin)');
+  if (!info.gh.authed) throw fail(400, 'Cal iniciar sessió a GitHub amb «gh auth login»');
+  await run('git', ['push', '-u', info.remote, 'HEAD'], { cwd, timeout: 120000 });
+  title = String(title || '').trim().slice(0, 200);
+  const args = ['pr', 'create'];
+  if (title) args.push('--title', title, '--body', String(body || '').slice(0, 5000));
+  else args.push('--fill');
+  const r = await run('gh', args, { cwd, timeout: 60000 });
+  const url = (r.stdout.match(/https:\/\/github\.com\/\S+/) || [])[0] || '';
+  return { ok: true, url };
+}
+
+module.exports = { status, repos, clone, gitInfo, commit, pr };

package/src/pair.js

@@ -40,6 +40,10 @@ function terminalQr(text, { color = !process.env.NO_COLOR } = {}) {
   return lines.join('\n');
 }
 
+function qrSvg(text) {
+  return qr(text).createSvgTag({ cellSize: 6, margin: 4, scalable: true });
+}
+
 function writePairPage(link) {
   const q = qr(link);
   const svg = q.createSvgTag({ cellSize: 6, margin: 4, scalable: true });
@@ -58,4 +62,4 @@ code{display:block;word-break:break-all;font:12px/1.5 ui-monospace,Menlo,monospa
   return file;
 }
 
-module.exports = { pairLink, terminalQr, writePairPage };
+module.exports = { pairLink, terminalQr, writePairPage, qrSvg };

package/src/server.js

@@ -9,6 +9,8 @@ const { detectAll } = require('./agents');
 const ollama = require('./agents/ollama');
 const { save } = require('./config');
 const { httpErr } = require('./hub');
+const github = require('./github');
+const { pairLink, qrSvg } = require('./pair');
 
 // L'app web: copiada dins del paquet en publicar-lo, o l'arrel del repositori en desenvolupament.
 const WEB_DIRS = [path.join(__dirname, '..', 'web'), path.join(__dirname, '..', '..')];
@@ -106,15 +108,38 @@ function listProjects(cfg) {
   return out;
 }
 
-function insideRoots(cfg, p) {
-  const r = path.resolve(p);
-  return cfg.roots.some((root) => r === root || r.startsWith(root + path.sep));
+// Qualsevol carpeta existent d'aquest ordinador. Qui té la clau ja pot engegar agents, així que no la limitem a les compartides.
+function isDir(p) {
+  try {
+    return fs.statSync(path.resolve(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Subcarpetes d'una carpeta, per a l'explorador de «Nova sessió».
+function listDir(cfg, raw) {
+  const dir = path.resolve(raw || cfg.roots[0] || os.homedir());
+  if (!isDir(dir)) throw httpErr(400, 'Aquesta carpeta no existeix');
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    throw httpErr(403, 'No tinc permís per veure aquesta carpeta');
+  }
+  const dirs = entries
+    .filter((e) => (e.isDirectory() || (e.isSymbolicLink() && isDir(path.join(dir, e.name)))) && e.name !== 'node_modules')
+    .map((e) => ({ name: e.name, path: path.join(dir, e.name), hidden: e.name.startsWith('.') }))
+    .sort((a, b) => a.hidden - b.hidden || a.name.localeCompare(b.name, 'ca'))
+    .slice(0, 500);
+  const parent = path.dirname(dir);
+  return { path: dir, parent: parent === dir ? null : parent, home: os.homedir(), git: fs.existsSync(path.join(dir, '.git')), dirs };
 }
 
 // Noms de model d'Ollama: «qwen3:4b», «hf.co/usuari/model:Q4_K_M»…
 const MODEL_NAME = /^[\w][\w.\-/]{0,100}(:[\w.\-]{1,60})?$/;
 
-function createServer({ cfg, hub, getPublicUrl }) {
+function createServer({ cfg, hub, getPublicUrl, getApp }) {
   const streams = new Set();
   const pulls = new Map(); // descàrregues de models d'Ollama en curs
 
@@ -147,6 +172,7 @@ function createServer({ cfg, hub, getPublicUrl }) {
       };
     }
     if (p === '/api/projects' && method === 'GET') return listProjects(cfg);
+    if (p === '/api/fs' && method === 'GET') return listDir(cfg, url.searchParams.get('path'));
     if (p === '/api/ollama/models' && method === 'GET') return (await ollama.listModels()) || [];
     if (p === '/api/ollama' && method === 'GET') {
       const models = await ollama.listModels();
@@ -201,12 +227,26 @@ function createServer({ cfg, hub, getPublicUrl }) {
       return { ok: true };
     }
 
+    if (p === '/api/pair' && method === 'GET') {
+      // Enllaç i QR per connectar un altre dispositiu (el mòbil) amb aquest ordinador.
+      const pub = getPublicUrl();
+      if (!pub || /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:|\/|$)/i.test(pub)) return { link: null };
+      const link = pairLink(getApp ? getApp() : cfg.app, pub, cfg.token);
+      return { link, svg: qrSvg(link), url: pub, lan: /^http:\/\//.test(pub) };
+    }
+    if (p === '/api/github' && method === 'GET') return github.status();
+    if (p === '/api/github/repos' && method === 'GET') return github.repos(url.searchParams.get('owner') || '');
+    if (p === '/api/github/clone' && method === 'POST') {
+      const b = await readBody(req);
+      const r = await github.clone(cfg, b.repo);
+      return r;
+    }
+
     if (p === '/api/sessions' && method === 'GET') return hub.list();
     if (p === '/api/sessions' && method === 'POST') {
       const b = await readBody(req);
       const cwd = path.resolve(b.cwd || cfg.roots[0]);
-      if (!insideRoots(cfg, cwd)) throw httpErr(403, 'Aquesta carpeta no és de les que has compartit en engegar nio');
-      if (!fs.existsSync(cwd)) throw httpErr(400, 'Aquesta carpeta no existeix');
+      if (!isDir(cwd)) throw httpErr(400, 'Aquesta carpeta no existeix');
       const s = hub.create({ agent: b.agent, cwd, title: b.title, mode: b.mode, model: b.model });
       if (b.text) hub.send(s.id, b.text, hookUrl());
       return hub.summary(s);
@@ -225,6 +265,13 @@ function createServer({ cfg, hub, getPublicUrl }) {
         return { ok: true };
       }
     }
+    if ((r = m(/^\/api\/sessions\/([\w-]+)\/git(?:\/(commit|pr))?$/))) {
+      const s = hub.get(r[1]);
+      if (!s) throw httpErr(404, 'Aquesta sessió no existeix');
+      if (!r[2] && method === 'GET') return github.gitInfo(s.cwd);
+      if (r[2] === 'commit' && method === 'POST') return github.commit(s.cwd, await readBody(req));
+      if (r[2] === 'pr' && method === 'POST') return github.pr(s.cwd, await readBody(req));
+    }
     if ((r = m(/^\/api\/sessions\/([\w-]+)\/message$/)) && method === 'POST') {
       const b = await readBody(req);
       return hub.send(r[1], b.text, hookUrl());