@dotrino/ia-agent 0.1.0 → 0.2.0

package/bin/cli.js

@@ -1,43 +1,88 @@
 #!/usr/bin/env node
 /**
- * dotrino-ia-agent — CLI del agente de IA.
- *   enroll <qr-json | ->   enropa esta máquina al vault como agente 'ia-agent'
- *   run                    arranca el agente (escucha chats desde la PWA)
+ * dotrino-ia-agent — agente de Dotrino IA.
+ *
+ *   dotrino-ia-agent            enlaza (si falta) y CORRE el agente
+ *   dotrino-ia-agent enroll     re-enlaza (sobrescribe) y corre el agente
+ *   opciones: [--label <nombre>] [--proxy <wss://…>] [--dir <ruta>]
+ *
+ * El agente es un dispositivo enrolado del vault (label 'ia-agent'): puede vivir en
+ * cualquier máquina y aparece solo en ia.dotrino.com para chatear con tus IAs
+ * (Claude, OpenCode…). Con un solo comando queda enlazado y sirviendo.
  */
-import { enroll, parseQr, dataDir } from '@dotrino/remote-agent/link'
+import readline from 'node:readline'
 import { startIaAgent } from '../index.js'
+import { enroll, parseQr, loadLink, dataDir } from '@dotrino/remote-agent/link'
 
-const DIR = dataDir('dotrino-ia-agent')
-const cmd = process.argv[2]
+const args = process.argv.slice(2)
+const cmd = args[0] && !args[0].startsWith('-') ? args[0] : 'run'
+const opt = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined }
 
-function readStdin () {
-  return new Promise((resolve) => {
-    let d = ''
-    process.stdin.setEncoding('utf8')
-    process.stdin.on('data', (c) => { d += c })
-    process.stdin.on('end', () => resolve(d.trim()))
+function ask (q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((res) => rl.question(q, (a) => { rl.close(); res(a) }))
+}
+
+if (args.includes('-h') || args.includes('--help')) {
+  console.log(`uso:
+  dotrino-ia-agent            enlaza esta máquina (si falta) y corre el agente
+  dotrino-ia-agent enroll     re-enlaza (sobrescribe el enlace) y corre el agente
+  opciones: [--label <nombre>] [--proxy <wss://…>] [--dir <ruta>]
+
+datos en ${dataDir('dotrino-ia-agent')} (override DOTRINO_REMOTE_AGENT_DIR)`)
+  process.exit(0)
+}
+
+async function doEnroll (dir, label) {
+  console.log('Enlazar esta máquina con tu vault.')
+  console.log('El código lo generas en el CERTIFICADOR (tu vault). Hay dos formas:')
+  console.log('  · Sin vault externo → abre https://ia.dotrino.com, elige')
+  console.log('    "Usar este dispositivo como bóveda" → "Enlazar otra máquina" y copia el código.')
+  console.log('  · Con vault en un PC → ahí corre `dotrino-vault pair` y copia el QR/JSON.\n')
+  const text = await ask('Pega el código y Enter:\n> ')
+  const qr = parseQr(text)
+  console.log('\nConectando…')
+  await enroll({
+    qr,
+    dir,
+    label,
+    onChallenge: ({ deviceId, code }) => {
+      console.log('\n  Escribe ESTE código en tu bóveda para aprobar esta máquina:')
+      console.log(`    código: ${code}`)
+      console.log(`    máquina: ${deviceId}`)
+      console.log('    (en ia.dotrino.com escríbelo en el campo y pulsa "Aprobar";')
+      console.log(`     en el PC del vault:  dotrino-vault approve ${code})\n`)
+      console.log('  Esperando aprobación…')
+    }
   })
+  console.log('\n  ✓ Máquina enlazada — levantando el agente…\n')
 }
 
-if (cmd === 'enroll') {
-  let qrText = process.argv[3]
-  if (!qrText || qrText === '-') qrText = await readStdin()
-  if (!qrText) { console.error('Uso: dotrino-ia-agent enroll "<qr-json>"   (o pega el QR por stdin con -)'); process.exit(1) }
-  try {
-    const link = await enroll({
-      qr: parseQr(qrText),
-      label: 'ia-agent',
-      dir: DIR,
-      onChallenge: ({ deviceId, code }) => console.log(`\nMáquina ${deviceId}\n  Tipeá este código en el vault: ${code}\n`)
-    })
-    console.log(`\n✓ Enrolado como 'ia-agent' (vault ${link.iss.slice(0, 16)}…).\n  Ahora arranca el agente: dotrino-ia-agent run\n`)
-  } catch (e) { console.error('Error:', e.message); process.exit(1) }
-} else if (cmd === 'run' || !cmd) {
-  try {
-    await startIaAgent({ dir: DIR })
-    console.log('(Ctrl+C para detener)')
-  } catch (e) { console.error('Error:', e.message); process.exit(1) }
-} else {
-  console.error('Comandos:\n  dotrino-ia-agent enroll "<qr-json>" | -\n  dotrino-ia-agent run')
+try {
+  const dir = opt('--dir')
+  const label = opt('--label') || 'ia-agent'
+  // El comando por defecto enrola SOLO si aún no está enlazada; `enroll` fuerza
+  // re-enrolar (sobrescribe) aunque ya lo esté. En ambos casos, al terminar sigue
+  // y LEVANTA el servicio.
+  if (cmd === 'enroll' || !loadLink(dir)) {
+    if (cmd === 'enroll' && loadLink(dir)) console.log('Re-enlazando esta máquina (sobrescribe el enlace actual).\n')
+    await doEnroll(dir, label)
+  }
+
+  const agent = await startIaAgent({
+    dir, proxyUrl: opt('--proxy'),
+    onRevoked: () => { console.log('  Esta máquina fue revocada desde tu bóveda. Para reconectarla, vuelve a enrolarla.\n'); process.exit(0) }
+  })
+  console.log('\n  Dotrino IA — agente activo')
+  console.log('  máquina:', agent.machineId)
+  console.log('  aparece solo en ia.dotrino.com\n')
+  // Mantener vivo el servicio aunque stdin no sea una TTY (systemd/pm2/`nohup </dev/null`):
+  // los sockets del proxy están `unref`'d, así que sin este keep-alive el proceso saldría
+  // justo después de arrancar. Vive hasta SIGINT/SIGTERM (o auto-borrado por revocación).
+  const keepAlive = setInterval(() => {}, 1 << 30)
+  const bye = () => { clearInterval(keepAlive); agent.close(); process.exit(0) }
+  process.on('SIGINT', bye); process.on('SIGTERM', bye)
+} catch (e) {
+  console.error('error:', e.message)
   process.exit(1)
 }

package/drivers/claude.js

@@ -0,0 +1,94 @@
+/**
+ * drivers/claude.js — invoca la CLI `claude` (Claude Code) en modo headless.
+ *
+ * F1: NO streaming. Lanza `claude -p "<texto>" --output-format json [--resume <sid>]`
+ * y devuelve el resultado completo cuando termina (igual que dotrino-telegram-claude-bot).
+ * F2 migrará esto al SDK (@anthropic-ai/claude-code) con onToken para streaming real.
+ *
+ * Memoria de sesión: guarda el `session_id` que devuelve Claude y lo pasa como
+ * `--resume` en la siguiente vuelta (hilo continuo). Si la sesión se invalida,
+ * arranca una nueva.
+ */
+import { spawn } from 'node:child_process'
+import { dirname } from 'node:path'
+
+// PATH robusto para systemd/PM2 (PATH mínimo): node + ~/.local/bin (donde vive `claude`).
+const EXTRA_PATH = [dirname(process.execPath), `${process.env.HOME || ''}/.local/bin`].filter(Boolean).join(':')
+
+export class ClaudeDriver {
+  /**
+   * @param {object} opts
+   * @param {string} [opts.cwd]      directorio donde opera Claude (el proyecto). Default process.cwd().
+   * @param {string} [opts.bin='claude']  binario a invocar.
+   * @param {string[]} [opts.flags=[]]    flags extra (p. ej. ['--dangerously-skip-permissions'] para yolo).
+   * @param {number} [opts.timeoutMs=0]   0 = sin límite.
+   */
+  constructor ({ cwd, bin = 'claude', flags = [], timeoutMs = 0 } = {}) {
+    this.cwd = cwd || process.cwd()
+    this.bin = bin
+    this.flags = flags
+    this.timeoutMs = timeoutMs
+    this.sessionId = null
+  }
+
+  /** Envía un mensaje y devuelve { text, sessionId, tokens } cuando termina. */
+  async send (text) {
+    let out
+    try {
+      out = await this._run(this._args(text, this.sessionId))
+    } catch (e) {
+      // Sesión inválida/inexistente → empezar una nueva en vez de fallar.
+      if (this.sessionId && /no conversation found|session/i.test(e.message || '')) {
+        this.sessionId = null
+        out = await this._run(this._args(text, null))
+      } else throw e
+    }
+    let result = out, sid = this.sessionId, tokens = 0
+    try {
+      const j = JSON.parse(out)
+      result = (j.result ?? out)
+      sid = j.session_id || sid
+      tokens = contextTokens(j)
+    } catch {}
+    if (sid) this.sessionId = sid
+    return { text: String(result || '(sin respuesta)'), sessionId: sid, tokens }
+  }
+
+  _args (text, sid) {
+    const args = ['-p', text, '--output-format', 'json', ...this.flags]
+    if (sid) args.push('--resume', sid)
+    return args
+  }
+
+  _run (args) {
+    return new Promise((resolve, reject) => {
+      // stdin cerrado para que `claude -p` no espere por él.
+      const p = spawn(this.bin, args, {
+        cwd: this.cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, PATH: `${process.env.PATH || ''}:${EXTRA_PATH}` }
+      })
+      let out = '', err = ''
+      p.stdout.on('data', (d) => { out += d })
+      p.stderr.on('data', (d) => { err += d })
+      const to = this.timeoutMs > 0
+        ? setTimeout(() => { try { p.kill('SIGKILL') } catch {}; reject(new Error('timeout')) }, this.timeoutMs)
+        : null
+      p.on('error', (e) => { if (to) clearTimeout(to); reject(new Error(`no se pudo ejecutar '${this.bin}' (¿instalado y en PATH?): ${e.message}`)) })
+      p.on('close', (code) => {
+        if (to) clearTimeout(to)
+        if (code === 0) resolve(out)
+        else reject(new Error(err.slice(0, 500) || `claude salió con código ${code}`))
+      })
+    })
+  }
+}
+
+/** Tamaño aproximado del contexto de la última vuelta (tokens enviados). */
+function contextTokens (j) {
+  const u = j && j.usage
+  if (!u) return 0
+  return (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0)
+}
+
+export default { ClaudeDriver }

package/index.js

@@ -4,11 +4,22 @@
  * Expone tus CLIs de IA (Claude, OpenCode…) al chat remoto, sobre
  * `@dotrino/remote-agent` (handshake E2E, emparejamiento con vault, revocación).
  *
- * F0: driver ECHO — devuelve el texto recibido. Sirve para validar el flujo extremo
- * a extremo (enrolamiento → descubrimiento → handshake → chat) antes de meter el
- * driver de Claude (F1). Reemplazar el cuerpo de `onSession` por el driver.
+ * F1: driver Claude (no-streaming) — `claude -p --output-format json --resume`.
+ * F2: migrar a SDK con streaming de tokens. F4: driver OpenCode.
+ *
+ * Configuración (env):
+ *   IA_CWD         directorio donde opera Claude (default: el cwd al lanzar).
+ *   CLAUDE_BIN     binario (default 'claude').
+ *   CLAUDE_FLAGS   flags extra, ej. '--dangerously-skip-permissions' (modo yolo).
+ *   CLAUDE_TIMEOUT segundos, 0 = sin límite.
  */
 import { startRemoteAgent } from '@dotrino/remote-agent/agent'
+import { ClaudeDriver } from './drivers/claude.js'
+
+const CWD = process.env.IA_CWD || process.cwd()
+const CLAUDE_BIN = process.env.CLAUDE_BIN || 'claude'
+const CLAUDE_FLAGS = (process.env.CLAUDE_FLAGS || '').split(/\s+/).filter(Boolean)
+const CLAUDE_TIMEOUT = Number(process.env.CLAUDE_TIMEOUT || 0) * 1000
 
 export async function startIaAgent (opts = {}) {
   return startRemoteAgent({
@@ -19,12 +30,15 @@ export async function startIaAgent (opts = {}) {
     onReady: opts.onReady,
     onRevoked: opts.onRevoked,
     onSession (session) {
+      // Un driver por sesión: cada chat abre su propio hilo de Claude con su contexto.
+      const driver = new ClaudeDriver({ cwd: CWD, bin: CLAUDE_BIN, flags: CLAUDE_FLAGS, timeoutMs: CLAUDE_TIMEOUT })
       session.on('message', async (msg) => {
-        if (msg?.type === 'msg' && typeof msg.text === 'string') {
-          // F0 — ECHO. F1+: session es un canal cifrado; pasalo al driver:
-          //   const reply = await claudeDriver.send(msg.text, { sessionId, onToken })
-          //   session.send({ type: 'done', text: reply })
-          await session.send({ type: 'done', text: 'echo: ' + msg.text })
+        if (msg?.type !== 'msg' || typeof msg.text !== 'string') return
+        try {
+          const r = await driver.send(msg.text)
+          await session.send({ type: 'done', text: r.text, sessionId: r.sessionId, tokens: r.tokens })
+        } catch (e) {
+          await session.send({ type: 'error', message: e.message })
         }
       })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/ia-agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Agente de Dotrino IA: expone tus CLIs de IA (Claude, OpenCode) al chat remoto de ia.dotrino.com, vía @dotrino/remote-agent.",
   "type": "module",
   "bin": {
@@ -11,7 +11,8 @@
   },
   "files": [
     "index.js",
-    "bin"
+    "bin",
+    "drivers"
   ],
   "scripts": {
     "start": "node bin/cli.js run"