Harness básico

import assert from "node:assert/strict";
import {mkdtempSync,readFileSync,writeFileSync,existsSync} from "node:fs";
import {tmpdir} from "node:os";
import {join} from "node:path";
import {spawnSync} from "node:child_process";
const pasta=mkdtempSync(join(tmpdir(),"curso-harness-"));
const estadoArquivo=join(pasta,"estado.json");
const artefatoArquivo=join(pasta,"relatorio.json");
const efeitosArquivo=join(pasta,"publicacoes.json");
writeFileSync(efeitosArquivo,"[]");
const salvar=(arquivo,objeto)=>writeFileSync(arquivo,JSON.stringify(objeto,null,2));
const ler=arquivo=>JSON.parse(readFileSync(arquivo,"utf8"));
function falhar(codigo){throw new Error(codigo);}
let inicial={execucaoId:"e1",versao:0,validadoVersao:null,aprovadoVersao:null,
  status:"novo",passos:0,maxPassos:12,prazo:1000,traces:[]};
salvar(estadoArquivo,inicial);
function carregar(){
  const estado=ler(estadoArquivo);
  if(typeof estado.execucaoId!=="string"||!Number.isInteger(estado.passos))
    falhar("CHECKPOINT_INVALIDO");
  return criarHarness(estado);
}
function criarHarness(estado){
  function persistir(){salvar(estadoArquivo,estado);}
  function trace(etapa,status){estado.traces.push({execucaoId:estado.execucaoId,etapa,status});persistir();}
  function artefatoAtual(){
    if(!existsSync(artefatoArquivo)) falhar("ARTEFATO_AUSENTE");
    const artefato=ler(artefatoArquivo);
    if(artefato.versao!==estado.versao) falhar("ARTEFATO_DIVERGENTE");
    return artefato;
  }
  const ferramentas={
    preparar({texto}){
      if(typeof texto!=="string"||!texto.trim()) falhar("TEXTO_INVALIDO");
      estado.versao++;
      salvar(artefatoArquivo,{versao:estado.versao,texto});
      estado.validadoVersao=null;estado.status="preparado";
      trace("preparar","concluido");
    },
    validar(){artefatoAtual();estado.validadoVersao=estado.versao;
      trace("validar","concluido");},
    publicar({perderResposta=false}={}){
      artefatoAtual();
      if(estado.validadoVersao!==estado.versao||estado.aprovadoVersao!==estado.versao)
        falhar("GATE_REPROVADO");
      const intencao=estado.execucaoId+":"+estado.versao;
      const efeitos=ler(efeitosArquivo);
      const anterior=efeitos.find(x=>x.intencao===intencao);
      if(anterior){estado.status="publicado";trace("publicar","replay");return anterior;}
      // Ledger local simula um serviço externo separado do checkpoint.
      const recibo={intencao,versao:estado.versao,recibo:"pub-"+(efeitos.length+1)};
      efeitos.push(recibo);salvar(efeitosArquivo,efeitos);
      if(perderResposta){estado.status="desconhecido";trace("publicar","resposta_perdida");
        falhar("RESPOSTA_PERDIDA");}
      estado.status="publicado";trace("publicar","confirmado");return recibo;
    },
    reconciliar(){
      const intencao=estado.execucaoId+":"+estado.versao;
      const recibo=ler(efeitosArquivo).find(x=>x.intencao===intencao);
      estado.status=recibo?"publicado":"nao_enviado";
      trace("reconciliar",estado.status);return recibo??null;
    }
  };
  return {estado,
    chamar(nome,args={},agora=0){
      if(!Object.hasOwn(ferramentas,nome)) falhar("TOOL_NAO_PERMITIDA");
      if(agora>=estado.prazo) falhar("TIMEOUT_GLOBAL");
      if(estado.passos>=estado.maxPassos) falhar("LIMITE_PASSOS");
      estado.passos++;persistir();
      try{return ferramentas[nome](args);}catch(erro){trace(nome,"falhou");throw erro;}
    },
    aprovar({ator,versao}){
      if(ator!=="operador-autorizado") falhar("ATOR_INVALIDO");
      if(versao!==estado.versao) falhar("APROVACAO_ANTIGA");
      artefatoAtual();estado.aprovadoVersao=versao;trace("aprovar","concluido");
    }
  };
}
let h=carregar();
h.chamar("preparar",{texto:"Relatório inicial"});h.chamar("validar");
h.aprovar({ator:"operador-autorizado",versao:1});
h.chamar("preparar",{texto:"Relatório revisado"});
assert.throws(()=>h.chamar("publicar"),/GATE_REPROVADO/);
assert.throws(()=>h.aprovar({ator:"operador-autorizado",versao:1}),/APROVACAO_ANTIGA/);
h.chamar("validar");h.aprovar({ator:"operador-autorizado",versao:2});
// Um processo novo lê o JSON persistido, sem acesso ao objeto h.
const reinicio=spawnSync(process.execPath,["--input-type=module","-e",
  "import {readFileSync} from 'node:fs';console.log(readFileSync(process.argv[1],'utf8'));",
  estadoArquivo],{encoding:"utf8"});
assert.equal(reinicio.status,0);assert.equal(JSON.parse(reinicio.stdout).versao,2);
h=carregar();
assert.throws(()=>h.chamar("publicar",{perderResposta:true}),/RESPOSTA_PERDIDA/);
assert.equal(ler(estadoArquivo).status,"desconhecido");
h=carregar();assert.equal(h.chamar("reconciliar").versao,2);
h.chamar("publicar");assert.equal(ler(efeitosArquivo).length,1);
assert.equal(h.estado.status,"publicado");
assert.throws(()=>h.chamar("terminal",{comando:"qualquer"}),/TOOL_NAO_PERMITIDA/);
assert.throws(()=>h.chamar("validar",{},1000),/TIMEOUT_GLOBAL/);
const limitado=criarHarness({...h.estado,passos:12,maxPassos:12});
assert.throws(()=>limitado.chamar("validar"),/LIMITE_PASSOS/);
assert.ok(h.estado.traces.some(x=>x.status==="resposta_perdida"));
assert.ok(h.estado.traces.some(x=>x.etapa==="reconciliar"));
console.log({status:"aprovado",pasta,publicacoes:ler(efeitosArquivo).length,
  checkpoint:h.estado.status,passos:h.estado.passos});