@dotrino/ia-agent 0.1.1 → 0.3.0

package/drivers/claude.js

@@ -0,0 +1,130 @@
+/**
+ * drivers/claude.js — invoca la CLI `claude` (Claude Code) con STREAMING real.
+ *
+ * F2: usa `--output-format stream-json --verbose` y parsea los eventos NDJSON que
+ * Claude re-emite del streaming de Anthropic. Los `content_block_delta` /
+ * `text_delta` son los tokens ⇒ los pasamos a `onToken` conforme se generan.
+ * El evento `result` final da `session_id`, `usage` y el texto completo (fallback).
+ *
+ * Memoria de sesión: `--resume <sid>` con el `session_id` del `result`. Si la sesión
+ * se invalida, arranca una nueva. Mismo patrón que dotrino-telegram-claude-bot.
+ */
+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).
+   * @param {string} [opts.bin='claude']
+   * @param {string[]} [opts.flags=[]]  flags extra (p. ej. '--dangerously-skip-permissions').
+   * @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. `onToken(text)` recibe los tokens conforme se generan.
+   * Devuelve { text, sessionId, tokens } al terminar.
+   */
+  async send (text, { onToken } = {}) {
+    try {
+      return await this._send(text, this.sessionId, onToken)
+    } 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
+        return this._send(text, null, onToken)
+      }
+      throw e
+    }
+  }
+
+  async _send (text, sid, onToken) {
+    const args = ['-p', text, '--output-format', 'stream-json', '--verbose', ...this.flags]
+    if (sid) args.push('--resume', sid)
+
+    let streamed = ''
+    let finalEv = null
+    let stderrText = ''
+
+    await this._runStream(args, {
+      onLine (line) {
+        let ev
+        try { ev = JSON.parse(line) } catch { return }
+        // Streaming real: deltas de texto del modelo (Anthropic content_block_delta).
+        const se = ev.event
+        if (ev.type === 'stream_event' && se?.type === 'content_block_delta' && se.delta?.type === 'text_delta' && se.delta.text) {
+          streamed += se.delta.text
+          onToken?.(se.delta.text)
+          return
+        }
+        // Resultado final: session_id + usage (+ result como fallback de texto).
+        if (ev.type === 'result') finalEv = ev
+      },
+      onStderr (d) { stderrText += d }
+    })
+
+    let out = streamed
+    let nextSid = sid
+    let tokens = 0
+    if (finalEv) {
+      if (!out && finalEv.result) out = String(finalEv.result)          // fallback: respuesta completa
+      if (finalEv.session_id) nextSid = finalEv.session_id
+      tokens = contextTokens(finalEv)
+    }
+    if (!out) {
+      if (finalEv?.is_error) throw new Error(String(finalEv.result || 'claude reportó un error'))
+      if (stderrText) throw new Error(stderrText.slice(0, 500))
+      throw new Error('claude no devolvió respuesta')
+    }
+    if (nextSid) this.sessionId = nextSid
+    return { text: out, sessionId: nextSid, tokens }
+  }
+
+  _runStream (args, { onLine, onStderr }) {
+    return new Promise((resolve, reject) => {
+      const p = spawn(this.bin, args, {
+        cwd: this.cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, PATH: `${process.env.PATH || ''}:${EXTRA_PATH}` }
+      })
+      let buf = ''
+      p.stdout.setEncoding('utf8')
+      p.stdout.on('data', (d) => {
+        buf += d
+        const lines = buf.split('\n')
+        buf = lines.pop()                         // último fragmento (posiblemente incompleto)
+        for (const ln of lines) if (ln.trim()) onLine(ln)
+      })
+      let errBuf = ''
+      p.stderr.on('data', (d) => { errBuf += d; onStderr?.(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)
+        // stream-json puede escribir su 'result' final y salir 0; errores no cero ⇒ rechazar.
+        if (code === 0 || code === null) resolve()
+        else reject(new Error(errBuf.slice(0, 500) || `claude salió con código ${code}`))
+      })
+    })
+  }
+}
+
+function contextTokens (ev) {
+  const u = ev && ev.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,23 @@
  * 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.
+ * F2: driver Claude con STREAMING real (stream-json). Los tokens del modelo se
+ * reenvían al cliente como mensajes `ia.tok` (batcheados ~60 ms para no saturar el
+ * proxy) y el cierre como `ia.done`. 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 +31,30 @@ 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
+
+        // Batch de tokens (~60 ms): el rate-limit del proxy es discreto; sin batch,
+        // una ráfaga de deltas saturaría. Flush al final siempre.
+        let buf = ''
+        let timer = null
+        const flush = () => { timer = null; if (buf) { const t = buf; buf = ''; session.send({ type: 'tok', text: t }).catch(() => {}) } }
+
+        try {
+          const r = await driver.send(msg.text, {
+            onToken: (tok) => {
+              buf += tok
+              if (!timer) timer = setTimeout(flush, 60)
+            }
+          })
+          if (timer) { clearTimeout(timer); timer = null }
+          if (buf) { const t = buf; buf = ''; await session.send({ type: 'tok', text: t }) }
+          await session.send({ type: 'done', sessionId: r.sessionId, tokens: r.tokens })
+        } catch (e) {
+          if (timer) clearTimeout(timer)
+          await session.send({ type: 'error', message: e.message }).catch(() => {})
         }
       })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/ia-agent",
-  "version": "0.1.1",
+  "version": "0.3.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"