@orkastery/cli 0.2.0 → 0.4.1

package/dist/adapters/codex-events.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserCodex = exports.LIMITE_LINHA_CODEX = void 0;
+exports.falhaDeContaDoErroCodex = falhaDeContaDoErroCodex;
+exports.classificarMensagem = classificarMensagem;
+/** D4/D5: stream e rollout são observações de turno, nunca aprovação de CHECK. */
+const gates_1 = require("../gates");
+const claude_bg_1 = require("./claude-bg");
+const indisponivel = () => ({ disponivel: false, input: null, cachedInput: null,
+    output: null, total: null, unidade: 'tokens', escopo: 'turno', fonte: 'unavailable' });
+const falha = () => ({ classificacao: 'gate_blocked', motivo: 'runtime.unavailable' });
+const sucesso = () => ({ classificacao: 'fase_concluida', motivo: null });
+const humano = () => ({ classificacao: 'human.pending', motivo: 'human.pending' });
+/** I-33 (D12): motivos da conta so saem de erro estruturado do runtime (`falhaDeContaDoErroCodex`). */
+const MOTIVOS_DA_CONTA = ['runtime.quota-exhausted', 'runtime.auth-missing'];
+function motivo(v) {
+    if (v === undefined || v === null)
+        return null;
+    if (typeof v !== 'string' || !Object.hasOwn(gates_1.DESCRICAO_DO_MOTIVO, v))
+        return falha();
+    // Texto do agente declarando cota ou login nao e evidencia da conta: vira falha comum.
+    if (MOTIVOS_DA_CONTA.includes(v))
+        return falha();
+    return v === 'human.pending' ? humano() : { classificacao: 'gate_blocked', motivo: v };
+}
+const LIMITE_ERRO_CODEX = 300;
+/**
+ * I-33 (D12): falha da conta no erro ESTRUTURADO do turno codex. O rollout grava
+ * `task_complete.error` com `codex_error_info` em snake_case (`usage_limit_exceeded`, a linha real
+ * do incidente de 18/09); o app-server manda `turn.error.codexErrorInfo` em camelCase
+ * (`usageLimitExceeded`, `unauthorized`). As duas formas viram o mesmo codigo; `unauthorized` e
+ * login perdido, o resto passa pelos padroes da D1 junto com a mensagem do runtime.
+ */
+function falhaDeContaDoErroCodex(erro, agoraMs = Date.now()) {
+    if (!erro || typeof erro !== 'object' || Array.isArray(erro))
+        return null;
+    const e = erro;
+    const info = e.codex_error_info ?? e.codexErrorInfo ?? e.codigo;
+    const bruto = typeof info === 'string' ? info
+        : info && typeof info === 'object' && !Array.isArray(info) ? Object.keys(info)[0] ?? '' : '';
+    const codigo = bruto.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase().replace(/[^a-z0-9_]/g, '').slice(0, 64);
+    const mensagem = typeof (e.message ?? e.mensagem) === 'string'
+        ? String(e.message ?? e.mensagem).replace(/\p{Cc}/gu, ' ').trim().slice(0, LIMITE_ERRO_CODEX) : '';
+    const trecho = [codigo, mensagem].filter(Boolean).join(': ').slice(0, 200);
+    if (codigo === 'unauthorized')
+        return { motivo: 'runtime.auth-missing', resetEm: null, fonte: 'sem-horario', trecho };
+    const sinal = (0, claude_bg_1.parseFalhaDeConta)(trecho, agoraMs);
+    return sinal ? { ...sinal, trecho } : null;
+}
+function classificarMensagem(texto) {
+    if (typeof texto !== 'string')
+        return sucesso();
+    // Trechos citados e exemplos de comandos não descrevem o estado deste turno.
+    const linhas = texto.replace(/```[\s\S]*?```/g, '').split('\n')
+        .filter(l => !/^\s*(?:>|["“])/.test(l));
+    const final = linhas.join('\n').trim().split(/\n\s*\n/).at(-1) ?? '';
+    const estado = /(?:^|\n)\s*(?:motivo|gate_blocked|bloquead[oa](?:\s+por)?|blocked(?:\s+by)?)\s*[:=]?\s*`?([a-z]+[._][a-z_.-]+)`?/i.exec(final);
+    if (estado)
+        return motivo(estado[1]) ?? falha();
+    const pergunta = final.replace(/`[^`]*`/g, '').trim();
+    if (/(?:preciso|aguardo|aguardando|waiting for|need)\s+(?:da?\s+)?(?:sua|your|confirmação|resposta|autorização|approval|confirmation)/i.test(pergunta))
+        return humano();
+    if (/\?\s*$/.test(pergunta) &&
+        /(?:\b(?:você|voce|you|confirma|confirme|deseja|prefere|autoriza|posso|can you|could you|should I)\b|(?:qual|which|what)\s+(?:é\s+o\s+|is\s+the\s+)?(?:diretório|diretorio|caminho|arquivo|opção|opcao|directory|path|file|option))/i.test(pergunta))
+        return humano();
+    return sucesso();
+}
+function tokens(v, fonte, escopo) {
+    if (!v || typeof v !== 'object')
+        return indisponivel();
+    const p = v;
+    const input = p.input_tokens ?? p.total_input_tokens;
+    const cached = p.cached_input_tokens ?? p.cache_read_input_tokens;
+    const output = p.output_tokens ?? p.total_output_tokens;
+    if (![input, output].every(n => Number.isSafeInteger(n) && Number(n) >= 0) ||
+        (cached !== undefined && (!Number.isSafeInteger(cached) || Number(cached) < 0 || Number(cached) > Number(input))))
+        return indisponivel();
+    const total = p.total_tokens ?? Number(input) + Number(output);
+    if (!Number.isSafeInteger(total) || Number(total) < Number(input) + Number(output))
+        return indisponivel();
+    return { disponivel: true, input: Number(input), cachedInput: cached === undefined ? null : Number(cached),
+        output: Number(output), total: Number(total), unidade: 'tokens', escopo, fonte };
+}
+exports.LIMITE_LINHA_CODEX = 1024 * 1024;
+class ParserCodex {
+    pendente = Buffer.alloc(0);
+    descartando = false;
+    estado;
+    eventosValidos = 0;
+    constructor(estado) {
+        this.estado = estado ? structuredClone(estado) : { turnId: null, turnIdOrigem: null, mensagem: null,
+            tokens: indisponivel(), invalido: false, turnos: 0 };
+        // Cursor antigo sem o campo nao vira proveniencia explicita por omissao.
+        this.estado.turnIdOrigem = this.estado.turnIdOrigem ?? null;
+    }
+    get bytesPendentes() { return this.pendente.length; }
+    push(chunk, agoraMs = Date.now()) {
+        const dados = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        const saida = [];
+        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_CODEX) {
+                try {
+                    if (linha.length) {
+                        const e = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(linha));
+                        const terminal = this.evento(e, agoraMs);
+                        if (terminal)
+                            saida.push(terminal);
+                    }
+                }
+                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_CODEX) {
+            this.descartando = true;
+            this.estado.invalido = true;
+            this.pendente = Buffer.alloc(0);
+        }
+        else if (!this.descartando)
+            this.pendente = Buffer.concat([this.pendente, resto]);
+        return saida;
+    }
+    evento(bruto, agoraMs) {
+        if (!bruto || typeof bruto !== 'object')
+            return null;
+        const e = bruto; // fronteira JSON validada campo a campo abaixo
+        const p = e.type === 'event_msg' ? e.payload : e;
+        if (!p || typeof p !== 'object' || typeof p.type !== 'string')
+            return null;
+        if (e.timestamp !== undefined && (typeof e.timestamp !== 'string' ||
+            !Number.isFinite(Date.parse(e.timestamp)) || Date.parse(e.timestamp) > agoraMs)) {
+            this.estado.invalido = true;
+            return null;
+        }
+        if (p.type === 'turn.started' || p.type === 'task_started') {
+            this.estado.turnos++;
+            this.estado.turnoAberto = true;
+            this.estado.turnoIniciadoEm = e.timestamp ?? null;
+            // A origem vem da presenca do campo na fonte, jamais do formato do valor.
+            const daFonte = typeof p.turn_id === 'string' && p.turn_id ? p.turn_id : null;
+            this.estado.turnId = daFonte ?? `stream-${this.estado.turnos}`;
+            this.estado.turnIdOrigem = daFonte === null ? 'gerado' : 'explicito';
+            this.estado.mensagem = null;
+            this.estado.tokens = indisponivel();
+            this.eventosValidos++;
+            return null;
+        }
+        const turnId = e.type === 'token_usage_record' ? e.payload?.turn_id : p.turn_id;
+        if (typeof turnId === 'string' && this.estado.turnId && turnId !== this.estado.turnId)
+            return null;
+        if (p.type === 'token_count') {
+            this.estado.tokens = tokens(p.info?.total_token_usage, 'rollout.token_count', 'sessao');
+            this.eventosValidos++;
+            return null;
+        }
+        if (e.type === 'token_usage_record') {
+            this.estado.tokens = tokens(e.payload?.turn_token_usage ?? e.payload?.usage, 'rollout.token_usage_record', 'turno');
+            this.eventosValidos++;
+            return null;
+        }
+        const resposta = e.type === 'response_item' && e.payload?.type === 'message' && e.payload?.role === 'assistant'
+            && Array.isArray(e.payload.content) ? e.payload.content.filter((c) => c.type === 'output_text' && typeof c.text === 'string').map((c) => c.text).join('\n') : undefined;
+        const mensagem = resposta ?? (p.type === 'item.completed' && p.item?.type === 'agent_message' ? p.item.text :
+            p.type === 'agent_message' ? p.message : undefined);
+        if (mensagem !== undefined) {
+            this.estado.mensagem = classificarMensagem(mensagem);
+            this.eventosValidos++;
+            return null;
+        }
+        if (!['turn.completed', 'turn.failed', 'task_complete', 'task_failed'].includes(p.type))
+            return null;
+        this.eventosValidos++;
+        this.estado.turnoAberto = false;
+        // I-33 (D12): turno com `error` estruturado nunca e conclusao, mesmo sem mensagem final.
+        const comErro = p.error !== undefined && p.error !== null;
+        const falhou = p.type === 'turn.failed' || p.type === 'task_failed' || comErro;
+        const conta = comErro ? falhaDeContaDoErroCodex(p.error, agoraMs) : null;
+        const explicito = motivo(p.motivo ?? p.reason);
+        const mensagemFinal = typeof p.last_agent_message === 'string' && p.last_agent_message.trim()
+            ? classificarMensagem(p.last_agent_message) : this.estado.mensagem ?? sucesso();
+        const classificacao = this.estado.invalido ? falha()
+            : conta ? { classificacao: 'gate_blocked', motivo: conta.motivo } : explicito ??
+                (mensagemFinal.classificacao !== 'fase_concluida' ? mensagemFinal : falhou ? falha() : sucesso());
+        if (p.usage !== undefined)
+            this.estado.tokens = tokens(p.usage, 'stream.turn.completed', 'turno');
+        return { ...classificacao, ...(conta && !this.estado.invalido ? { falhaDeConta: conta } : {}), turnId: this.estado.turnId,
+            turnIdOrigem: this.estado.turnId === null ? null : this.estado.turnIdOrigem ?? null, timestamp: e.timestamp ?? new Date(agoraMs).toISOString(),
+            numeroTurno: this.estado.turnos, timestampFonte: e.timestamp ? 'evento' : 'observacao',
+            fonte: e.type === 'event_msg' ? `rollout.${p.type}` : `stream.${p.type}`,
+            tokens: structuredClone(this.estado.tokens),
+            duracaoMs: Number.isFinite(p.duration_ms) && p.duration_ms >= 0 ? p.duration_ms : null };
+    }
+}
+exports.ParserCodex = ParserCodex;

package/dist/adapters/codex-question.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projetarPergunta = projetarPergunta;
+/** Projeção explícita de conteúdo nativo. Segredos nunca saem para o canal HITL. */
+const node_crypto_1 = require("node:crypto");
+function projetarPergunta(params) {
+    if (params?.isBlocking !== true)
+        throw new Error('runtime.unavailable: question.nonblocking');
+    if (!Array.isArray(params.questions) || params.questions.length !== 1)
+        throw new Error('runtime.unavailable: question.multiple');
+    const q = params.questions[0];
+    if (q?.isSecret === true)
+        throw new Error('runtime.unavailable: question.secret');
+    const texto = (s, max) => typeof s === 'string' && !!s.trim() && s.length <= max && !/[\x00-\x08\x0b-\x1f\x7f]/.test(s);
+    if (!texto(q?.id, 100) || !texto(q?.question, 2000) || q.header !== undefined && (typeof q.header !== 'string' || q.header.length > 200) ||
+        q.isSecret !== undefined && q.isSecret !== false || q.isOther !== undefined && typeof q.isOther !== 'boolean' ||
+        q.options != null && (!Array.isArray(q.options) || q.options.length > 12 || q.options.some((o) => !texto(o?.label, 200) || !texto(o?.description, 1000) || `${o.label} — ${o.description}`.length > 200)))
+        throw new Error('runtime.unavailable: question.invalid');
+    const options = (q.options ?? []).map((o) => ({ label: o.label, description: o.description }));
+    if (new Set(options.map((o) => o.label)).size !== options.length)
+        throw new Error('runtime.unavailable: question.invalid');
+    // Nenhum spread do runtime: somente os campos que definem a pergunta suportada.
+    const content = { id: q.id, question: q.question, header: (q.header ?? ''),
+        isSecret: false, isOther: q.isOther === true, options };
+    return { ...content, sha256: (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(content)).digest('hex') };
+}

package/dist/adapters/codex-runner.js

@@ -0,0 +1,133 @@
+"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.identidadeProcesso = identidadeProcesso;
+exports.estadoProcesso = estadoProcesso;
+exports.gravarAtomico = gravarAtomico;
+exports.iniciarSupervisor = iniciarSupervisor;
+/** D4: supervisor independente do dispatcher, recibo derivado de close/error reais. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+function identidadeProcesso(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const campos = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        const inicio = campos[19];
+        if (!/^\d+$/.test(inicio))
+            return null;
+        return { pid, inicio, boot: fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim() };
+    }
+    catch {
+        return null;
+    }
+}
+function estadoProcesso(id) {
+    if (!id || !Number.isSafeInteger(id.pid) || id.pid <= 0 || !id.inicio || !id.boot)
+        return 'desconhecido';
+    const atual = identidadeProcesso(id.pid);
+    if (!atual) {
+        try {
+            process.kill(id.pid, 0);
+            return 'desconhecido';
+        }
+        catch (e) {
+            return e.code === 'ESRCH' ? 'ausente' : 'desconhecido';
+        }
+    }
+    if (atual.inicio !== id.inicio || atual.boot !== id.boot)
+        return 'ausente';
+    try {
+        const stat = fs.readFileSync(`/proc/${id.pid}/stat`, 'utf8');
+        if (stat.slice(stat.lastIndexOf(')') + 2).startsWith('Z '))
+            return 'ausente';
+    }
+    catch {
+        return 'desconhecido';
+    }
+    return 'vivo';
+}
+function gravarAtomico(file, valor) {
+    const tmp = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(valor) + '\n', { mode: 0o600, flag: 'wx' });
+    fs.renameSync(tmp, file);
+}
+function iniciarSupervisor(comando, cwd, logPath, env) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    // FD anônimo: o pedido não fica em argv, nem em um arquivo de configuração persistente.
+    const tmp = `${logPath}.${(0, node_crypto_1.randomUUID)()}.launch`;
+    fs.writeFileSync(tmp, JSON.stringify({ comando, cwd, logPath }), { flag: 'wx', mode: 0o600 });
+    const input = fs.openSync(tmp, 'r');
+    fs.unlinkSync(tmp);
+    try {
+        const child = (0, node_child_process_1.spawn)(process.execPath, [__filename, '--run'], {
+            cwd, env, detached: true, stdio: [input, 'ignore', 'ignore'],
+        });
+        child.on('error', () => { });
+        child.unref();
+    }
+    finally {
+        fs.closeSync(input);
+    }
+    return { processoPath: logPath + '.process.json', reciboPath: logPath + '.exit.json' };
+}
+function supervisionar() {
+    const pedido = JSON.parse(fs.readFileSync(0, 'utf8'));
+    const start = Date.now();
+    const dados = { schema: 'ork.codex-process/v1', iniciadoEm: new Date(start).toISOString(),
+        supervisor: identidadeProcesso(process.pid), filho: null };
+    const out = fs.openSync(pedido.logPath, 'ax', 0o600);
+    const err = fs.openSync(pedido.logPath + '.stderr', 'ax', 0o600);
+    let erro = null;
+    const filho = (0, node_child_process_1.spawn)(pedido.comando[0], pedido.comando.slice(1), { cwd: pedido.cwd, stdio: ['ignore', out, err], env: process.env });
+    fs.closeSync(out);
+    fs.closeSync(err);
+    dados.filho = filho.pid ? identidadeProcesso(filho.pid) : null;
+    gravarAtomico(pedido.logPath + '.process.json', dados);
+    filho.once('error', e => { erro = e.code ?? 'spawn.error'; });
+    filho.once('close', (code, signal) => {
+        const recibo = { ...dados, terminadoEm: new Date().toISOString(), exitCode: code,
+            signal, duracaoMs: Date.now() - start, erro };
+        gravarAtomico(pedido.logPath + '.exit.json', recibo);
+    });
+    // Parada controlada é encaminhada; SIGKILL do supervisor nunca fabrica recibo.
+    for (const sinal of ['SIGTERM', 'SIGINT'])
+        process.on(sinal, () => { filho.kill(sinal); });
+}
+if (require.main === module && process.argv[2] === '--run')
+    supervisionar();