@orkastery/cli 0.5.6 → 0.6.1

package/dist/adapters/grok-events.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserGrok = exports.LIMITE_ERRO_GROK = exports.LIMITE_LINHA_GROK = exports.STOP_CANCELADO = exports.STOP_FIM_NORMAL = void 0;
+exports.redigirTextoGrok = redigirTextoGrok;
+exports.redigirErroGrok = redigirErroGrok;
+exports.tokensDoFim = tokensDoFim;
+exports.falhaDeContaDoTextoGrok = falhaDeContaDoTextoGrok;
+exports.falhaDoErroGrok = falhaDoErroGrok;
+exports.lerStreamGrok = lerStreamGrok;
+/**
+ * RM-067 (F2 da ork-grokbuild, D7): o stream `streaming-json` do Grok Build (`grok -p ... --output-format
+ * streaming-json`), lido por linha.
+ *
+ * Formato do guia `14-headless-mode` do repositório `xai-org/grok-build`, lido em 25/10/2026: NDJSON com `type`. O `end`
+ * é sempre o último evento e traz `stopReason` em snake_case (`end_turn`, `max_tokens`, `max_turn_requests`, `refusal`,
+ * `cancelled`), `sessionId`, `requestId`, `usage`, `num_turns`, `modelUsage` e, só quando o servidor informa o custo
+ * inteiro, `total_cost_usd`; o `error` traz `message`. A lista de tipos não é exaustiva (`max_turns_reached`,
+ * `auto_compact_*`): tipo desconhecido é ignorado. O texto do agente (`text`, `thought`) nunca classifica nada; só o
+ * `end` e o `error`, que o próprio runtime grava, entram no resultado.
+ */
+const fs = __importStar(require("node:fs"));
+const hitl_1 = require("../hitl");
+const claude_bg_1 = require("./claude-bg");
+/** O `stopReason` do fim normal do turno. */
+exports.STOP_FIM_NORMAL = 'end_turn';
+/** O `stopReason` do turno cancelado: interrupção, como a saída 130 e a 143. */
+exports.STOP_CANCELADO = 'cancelled';
+/** Linha maior que isto não é evento: invalida o stream sem reter a memória. */
+exports.LIMITE_LINHA_GROK = 1024 * 1024;
+/** Teto da mensagem de erro do runtime que vai ao ledger. */
+exports.LIMITE_ERRO_GROK = 300;
+const STOP = /^[a-z][a-z0-9_]{0,39}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+/**
+ * D7: um texto do runtime pronto para o ledger, sem corte: os segredos que o núcleo já conhece, a chave da xAI
+ * (`xai-...`) e sem controle. GO-FIX 1 (A4): quem corta, corta depois de redigir, para nenhum segredo perder o prefixo.
+ */
+function redigirTextoGrok(texto) {
+    if (typeof texto !== 'string')
+        return '';
+    return (0, hitl_1.redigirSegredos)(texto)
+        .replace(/\bxai-[A-Za-z0-9_-]{16,}/g, '[redigido]')
+        .replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim();
+}
+/** D7: a mensagem de erro do runtime, redigida e até `LIMITE_ERRO_GROK` caracteres, sem partir par substituto. */
+function redigirErroGrok(texto) {
+    return Array.from(redigirTextoGrok(texto)).slice(0, exports.LIMITE_ERRO_GROK).join('');
+}
+const tokensIndisponiveis = () => ({ disponivel: false, input: null, cachedInput: null, output: null,
+    total: null, unidade: 'tokens', escopo: 'sessao', fonte: 'unavailable' });
+/** O `usage` do `end`, só com inteiros não negativos e total que cobre entrada e saída; fora disso, indisponível. */
+function tokensDoFim(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return tokensIndisponiveis();
+    const u = v;
+    const inteiro = (n) => Number.isSafeInteger(n) && n >= 0;
+    const input = u.input_tokens, output = u.output_tokens, cache = u.cache_read_input_tokens;
+    if (!inteiro(input) || !inteiro(output) || (cache !== undefined && !inteiro(cache)))
+        return tokensIndisponiveis();
+    const total = u.total_tokens === undefined ? input + output : u.total_tokens;
+    if (!inteiro(total) || total < input + output)
+        return tokensIndisponiveis();
+    return { disponivel: true, input, cachedInput: cache === undefined ? null : cache, output, total, unidade: 'tokens',
+        escopo: 'sessao', fonte: 'grok.end.usage' };
+}
+class ParserGrok {
+    pendente = Buffer.alloc(0);
+    descartando = false;
+    estado;
+    /** Eventos válidos lidos por esta instância: o progresso de uma leitura. */
+    eventosValidos = 0;
+    constructor(sessaoEsperada, estado) {
+        if (estado && estado.sessaoEsperada !== sessaoEsperada)
+            throw new Error('estado do parser do grok de outra sessão');
+        this.estado = estado ? structuredClone(estado)
+            : { sessaoEsperada, fim: null, erro: null, invalido: false, sessaoDivergente: false, eventos: 0 };
+    }
+    /** Lê as linhas completas do bloco; o resto fica pendente para o próximo. */
+    push(chunk) {
+        const dados = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        let inicio = 0;
+        for (let i = 0; i < dados.length; i++) {
+            if (dados[i] !== 10)
+                continue;
+            const linha = Buffer.concat([this.pendente, dados.subarray(inicio, i)]);
+            if (!this.descartando && linha.length <= exports.LIMITE_LINHA_GROK) {
+                if (linha.length) {
+                    try {
+                        this.evento(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(linha)));
+                    }
+                    catch {
+                        this.estado.invalido = true;
+                    }
+                }
+            }
+            else
+                this.estado.invalido = true;
+            this.pendente = Buffer.alloc(0);
+            this.descartando = false;
+            inicio = i + 1;
+        }
+        const resto = dados.subarray(inicio);
+        if (this.pendente.length + resto.length > exports.LIMITE_LINHA_GROK) {
+            this.descartando = true;
+            this.estado.invalido = true;
+            this.pendente = Buffer.alloc(0);
+        }
+        else if (!this.descartando)
+            this.pendente = Buffer.concat([this.pendente, resto]);
+    }
+    evento(bruto) {
+        if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto)) {
+            this.estado.invalido = true;
+            return;
+        }
+        const e = bruto;
+        if (typeof e.type !== 'string' || e.type === '') {
+            this.estado.invalido = true;
+            return;
+        }
+        // O guia diz que o `end` é sempre o último: outro `end` ou um `error` depois dele é contrato quebrado.
+        if (this.estado.fim && (e.type === 'end' || e.type === 'error')) {
+            this.estado.invalido = true;
+            return;
+        }
+        this.eventosValidos++;
+        this.estado.eventos++;
+        if (e.type === 'error') {
+            this.estado.erro = { mensagem: redigirErroGrok(e.message) || 'erro do grok sem mensagem' };
+            return;
+        }
+        if (e.type !== 'end')
+            return;
+        const sessionId = typeof e.sessionId === 'string' && ID.test(e.sessionId) ? e.sessionId : null;
+        if (sessionId !== this.estado.sessaoEsperada)
+            this.estado.sessaoDivergente = true;
+        this.estado.fim = {
+            stopReason: typeof e.stopReason === 'string' && STOP.test(e.stopReason) ? e.stopReason : 'desconhecido',
+            sessionId,
+            requestId: typeof e.requestId === 'string' && ID.test(e.requestId) ? e.requestId : null,
+            numTurnos: Number.isSafeInteger(e.num_turns) && e.num_turns >= 0 ? e.num_turns : null,
+            tokens: tokensDoFim(e.usage),
+            custoUsd: typeof e.total_cost_usd === 'number' && Number.isFinite(e.total_cost_usd) && e.total_cost_usd >= 0
+                ? e.total_cost_usd : null,
+        };
+    }
+}
+exports.ParserGrok = ParserGrok;
+/**
+ * D7 e RM-067 (F3): a falha da CONTA dita por um texto do `grok` (a mensagem do `error` ou o stderr), pelo critério único
+ * da D16 (`parseFalhaDeConta`), sem a cota. O formato do erro de cota esgotada do `grok` não está confirmado (E5 da página
+ * da RM-067): a fonte não diz o campo nem a mensagem. O sinal tipado de cota só pode vir de erro estruturado do runtime, e
+ * uma frase parecida marcaria o perfil e tiraria a conta do rodízio por suposição; até o ensaio real (F5) ler o formato,
+ * nenhum texto do `grok` vira `runtime.quota-exhausted`, e o `grok` fica fora da escada automática e do fallback por
+ * cota. O login e o modelo seguem pela frase, como na F2.
+ */
+function falhaDeContaDoTextoGrok(texto, agoraMs = Date.now()) {
+    const falha = (0, claude_bg_1.parseFalhaDeConta)(texto, agoraMs);
+    return falha?.motivo === 'runtime.quota-exhausted' ? null : falha;
+}
+/**
+ * D7: a falha da CONTA dita pelo próprio runtime no objeto `error` do stream (login, modelo), sem a cota
+ * (`falhaDeContaDoTextoGrok`): o que a frase não tipa fica `null`, e a parada segue tipada como `runtime.unavailable`.
+ */
+function falhaDoErroGrok(erro, agoraMs = Date.now()) {
+    return erro ? falhaDeContaDoTextoGrok(erro.mensagem, agoraMs) : null;
+}
+/**
+ * O stream inteiro de um despacho curto (a falha antes da sessão), lido sem seguir link e até `limiteBytes`; `null`
+ * quando o arquivo não existe, não é arquivo comum ou passa do limite.
+ */
+function lerStreamGrok(arquivo, sessaoEsperada, limiteBytes = 8 * 1024 * 1024) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > limiteBytes)
+            return null;
+        const bytes = Buffer.alloc(st.size);
+        fs.readSync(fd, bytes, 0, st.size, 0);
+        const parser = new ParserGrok(sessaoEsperada);
+        // A última linha sem quebra também é evento: o processo terminou e não vai completá-la.
+        parser.push(bytes.length && bytes[bytes.length - 1] !== 10 ? Buffer.concat([bytes, Buffer.from('\n')]) : bytes);
+        return parser.estado;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}