terminal-smart-cli 0.32.0

package/lib/acp.js

@@ -0,0 +1,191 @@
+// lib/acp.js — servidor ACP (Agent Client Protocol) do ts sobre stdio.
+//
+// ACP é o protocolo JSON-RPC 2.0 (mensagens JSON delimitadas por \n, NÃO framing
+// Content-Length do LSP) que editores como o Zed usam pra dirigir um agente de
+// código. O editor lança `ts acp` como subprocesso e conversa por stdin/stdout.
+//
+// Implementa o NÚCLEO:
+//   • initialize            — handshake + capacidades
+//   • authenticate          — no-op (a sessão ts vem do `ts login` local)
+//   • session/new           — cria sessão (cwd do projeto) → sessionId
+//   • session/prompt        — roda o agente e faz STREAMING de session/update
+//                             (tool_call / tool_call_update / agent_message_chunk),
+//                             devolve { stopReason }
+//   • session/cancel        — notificação; marca a sessão como cancelada
+// Comando DESTRUTIVO → pede session/request_permission ao editor (bidirecional):
+// o agente manda um request e ESPERA a escolha do usuário no IDE.
+//
+// REGRA DE OURO do stdio: stdout carrega SÓ mensagens do protocolo. TODO log vai
+// pra stderr — um console.log solto corromperia o JSON-RPC.
+const readline = require('readline');
+const path = require('path');
+const agent = require('./agent');
+
+const PROTOCOL_VERSION = 1;
+
+// kind da tool call (dica de ícone pro editor)
+function _kindOf(name) {
+  const n = String(name || '');
+  if (/escrever|editar|criar|restaurar/i.test(n)) return 'edit';
+  if (/ler|listar|buscar|mapa|info|planilha/i.test(n)) return 'read';
+  if (/executar|comando|remoto/i.test(n)) return 'execute';
+  if (/explorar/i.test(n)) return 'think';
+  return 'other';
+}
+
+function acpServer({ token, lang = 'pt' }) {
+  const write = (obj) => { try { process.stdout.write(JSON.stringify(obj) + '\n'); } catch (_) {} };
+  const log = (...a) => { try { process.stderr.write('[ts acp] ' + a.join(' ') + '\n'); } catch (_) {} };
+  const notify = (method, params) => write({ jsonrpc: '2.0', method, params });
+  const reply = (id, result) => write({ jsonrpc: '2.0', id, result: result === undefined ? {} : result });
+  const replyErr = (id, code, message) => write({ jsonrpc: '2.0', id, error: { code, message } });
+
+  const sessions = new Map();  // sessionId → { cwd, cancelled }
+  const pending = new Map();   // id → resolve  (requests que NÓS enviamos ao cliente)
+  let seq = 0;
+
+  // envia um REQUEST ao cliente (ex.: pedir permissão) e espera a resposta. TIMEOUT:
+  // se o editor não responder em 5 min, resolve null (→ o chamador nega, fail-safe). O
+  // sid amarra o pending à sessão pra que session/cancel possa destravá-lo na hora.
+  const clientRequest = (method, params, sid, timeoutMs = 300000) => new Promise((resolve) => {
+    const id = 'ts-' + (++seq);
+    let done = false, timer = null;
+    const finish = (v) => { if (done) return; done = true; if (timer) clearTimeout(timer); pending.delete(id); resolve(v); };
+    pending.set(id, { finish, sid });
+    timer = setTimeout(() => { log('timeout esperando resposta de ' + method); finish(null); }, timeoutMs);
+    if (timer.unref) timer.unref();
+    write({ jsonrpc: '2.0', id, method, params });
+  });
+
+  const handlers = {
+    initialize: async (params) => {
+      const pv = Number(params && params.protocolVersion) || PROTOCOL_VERSION;
+      return {
+        protocolVersion: Math.min(PROTOCOL_VERSION, pv),
+        agentCapabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: true } },
+        authMethods: [],
+      };
+    },
+    authenticate: async () => ({}), // a autenticação real é o `ts login` (sessão sk-hub local)
+    'session/new': async (params) => {
+      const cwd = (params && params.cwd) ? path.resolve(String(params.cwd)) : process.cwd();
+      const id = 'sess-' + (++seq) + '-' + Date.now().toString(36);
+      sessions.set(id, { cwd, cancelled: false });
+      log('nova sessão', id, 'cwd=' + cwd);
+      return { sessionId: id };
+    },
+    'session/prompt': async (params) => {
+      const sid = params && params.sessionId;
+      const sess = sessions.get(sid);
+      if (!sess) { const e = new Error('sessão desconhecida'); e.code = -32602; throw e; }
+      if (!token) {
+        notify('session/update', { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Não autenticado. Rode `ts login` no terminal e reabra o editor.' } } });
+        return { stopReason: 'refusal' };
+      }
+      // barra prompt CONCORRENTE na mesma sessão: sobreporia sess.cancelled e os toolCallId
+      // (o editor associaria updates ao widget errado). Um prompt por sessão de cada vez.
+      if (sess.running) {
+        notify('session/update', { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: lang === 'en' ? 'A prompt is already running in this session.' : 'Já há uma execução em andamento nesta sessão.' } } });
+        return { stopReason: 'refusal' };
+      }
+      // extrai o texto dos blocos de conteúdo do prompt
+      const blocks = Array.isArray(params.prompt) ? params.prompt : [];
+      const text = blocks.filter(b => b && (b.type === 'text' || typeof b.text === 'string')).map(b => b.text || '').join('\n').trim();
+      if (!text) return { stopReason: 'end_turn' };
+
+      sess.cancelled = false;
+      sess.running = true;
+      let out = null;
+      try {
+        out = await agent.run(text, {
+          token, lang, yes: false, cwd: sess.cwd, confineDir: null,
+          shouldStop: () => sess.cancelled, // cancelamento cooperativo: para no próximo passo
+          onThinking: () => {},
+          onStep: ({ name, detail, blocked }) => {
+            const tcid = 'tc-' + (++seq); // id GLOBAL → nunca colide entre prompts/sessões
+            // tool_call (início) + tool_call_update (fim) — nosso onStep dispara já
+            // com o passo concluído, então mandamos os dois em sequência.
+            notify('session/update', { sessionId: sid, update: {
+              sessionUpdate: 'tool_call', toolCallId: tcid,
+              title: name + (detail ? ' · ' + detail : ''), kind: _kindOf(name),
+              status: blocked ? 'failed' : 'in_progress',
+            } });
+            notify('session/update', { sessionId: sid, update: {
+              sessionUpdate: 'tool_call_update', toolCallId: tcid,
+              status: blocked ? 'failed' : 'completed',
+            } });
+          },
+          askApprove: async (cmd) => {
+            if (sess.cancelled) return false;
+            // pede a decisão ao EDITOR (o usuário aprova/recusa na UI do IDE)
+            const res = await clientRequest('session/request_permission', {
+              sessionId: sid,
+              toolCall: { toolCallId: 'perm-' + (++seq), title: 'Comando destrutivo: ' + cmd, kind: 'execute' },
+              options: [
+                { optionId: 'allow', name: lang === 'en' ? 'Allow once' : 'Permitir', kind: 'allow_once' },
+                { optionId: 'reject', name: lang === 'en' ? 'Reject' : 'Recusar', kind: 'reject_once' },
+              ],
+            }, sid);
+            const o = res && res.outcome;
+            return !!(o && o.outcome === 'selected' && o.optionId === 'allow');
+          },
+          onRemote: () => {},
+        });
+      } catch (e) {
+        if (e && (e.code === 'no_credits' || e.status === 402)) {
+          notify('session/update', { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: lang === 'en' ? 'AI limit reached on this plan — top up/upgrade to continue.' : 'Limite de IA do plano atingido — recarregue/upgrade pra continuar.' } } });
+          return { stopReason: 'refusal' };
+        }
+        log('erro no prompt:', String((e && e.message) || e));
+        notify('session/update', { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: (lang === 'en' ? 'Error: ' : 'Erro: ') + String((e && e.message) || e) } } });
+        return { stopReason: 'refusal' };
+      } finally {
+        sess.running = false;
+      }
+      if (sess.cancelled) return { stopReason: 'cancelled' };
+      // texto final do agente → chunk de mensagem
+      if (out && out.text) notify('session/update', { sessionId: sid, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: out.text } } });
+      return { stopReason: 'end_turn' };
+    },
+    // NOTIFICAÇÃO (sem id): marca cancelamento (o agente para no próximo passo via
+    // shouldStop) E destrava qualquer permissão em voo DESTA sessão (→ nega na hora),
+    // senão a run ficaria presa até o timeout de 5 min esperando o editor.
+    'session/cancel': async (params) => {
+      const sid = params && params.sessionId;
+      const sess = sessions.get(sid);
+      if (sess) sess.cancelled = true;
+      for (const [, p] of pending) if (p.sid === sid) p.finish(null);
+      return undefined;
+    },
+  };
+
+  // loop de entrada: uma mensagem JSON-RPC por LINHA.
+  const rl = readline.createInterface({ input: process.stdin });
+  rl.on('line', async (line) => {
+    line = String(line || '').trim();
+    if (!line) return;
+    let msg; try { msg = JSON.parse(line); } catch (_) { log('linha não-JSON ignorada'); return; }
+    // é uma RESPOSTA (tem result/error e nenhum method)? só nos interessa se casa com um
+    // request NOSSO pendente; órfã a gente IGNORA (nunca responder a uma resposta).
+    if (msg.method === undefined && (msg.result !== undefined || msg.error !== undefined)) {
+      const p = (msg.id !== undefined) ? pending.get(msg.id) : null;
+      if (p) p.finish(msg.error ? null : msg.result); // finish já limpa o pending
+      return;
+    }
+    // REQUEST ou NOTIFICAÇÃO vinda do cliente
+    const h = handlers[msg.method];
+    if (!h) { if (msg.id !== undefined) replyErr(msg.id, -32601, 'método não implementado: ' + msg.method); return; }
+    try {
+      const result = await h(msg.params || {});
+      if (msg.id !== undefined) reply(msg.id, result);
+    } catch (e) {
+      // code do JSON-RPC DEVE ser inteiro (ApiError/erros de SO têm .code string) → blinda.
+      if (msg.id !== undefined) replyErr(msg.id, Number.isInteger(e && e.code) ? e.code : -32603, String((e && e.message) || e));
+      else log('erro em notificação', msg.method, String((e && e.message) || e));
+    }
+  });
+  rl.on('close', () => process.exit(0));
+  log('pronto (protocolo ' + PROTOCOL_VERSION + ')');
+}
+
+module.exports = { acpServer, PROTOCOL_VERSION, _kindOf };