@orkastery/cli 0.6.5 → 0.6.7

package/dist/security-scan/guard.js

@@ -156,12 +156,15 @@ function launch(pgidFile, timeoutMs, bin, args) {
     child.on('error', e => { process.stderr.write(`${e.message}\n`); process.exit(127); });
     if (child.pid)
         fs.writeFileSync(pgidFile, String(child.pid));
-    const timer = setTimeout(() => { fs.writeFileSync(`${pgidFile}${exports.LAUNCH_TIMEOUT_SUFFIX}`, ''); kill(); }, timeoutMs);
+    const timer = Number.isFinite(timeoutMs)
+        ? setTimeout(() => { fs.writeFileSync(`${pgidFile}${exports.LAUNCH_TIMEOUT_SUFFIX}`, ''); kill(); }, timeoutMs)
+        : undefined;
     for (const s of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
         process.on(s, () => { kill(); process.exit(128 + (os.constants.signals[s] ?? 15)); });
     }
     child.on('exit', (code, signal) => {
-        clearTimeout(timer);
+        if (timer)
+            clearTimeout(timer);
         kill(); // background processes the tool left in its group
         fs.rmSync(pgidFile, { force: true });
         process.exit(code ?? 128 + (signal ? os.constants.signals[signal] ?? 9 : 9));

package/dist/session-watcher.js

@@ -39,6 +39,8 @@ exports.reconciliarSessaoSemWatcher = reconciliarSessaoSemWatcher;
 exports.validarRegistroWatcher = validarRegistroWatcher;
 exports.validarFonteWatcher = validarFonteWatcher;
 exports.prepararFonteWatcher = prepararFonteWatcher;
+exports.esperarProntidaoWatcher = esperarProntidaoWatcher;
+exports.esperarConfirmacaoDoPaiWatcher = esperarConfirmacaoDoPaiWatcher;
 exports.iniciarWatcher = iniciarWatcher;
 exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
@@ -906,6 +908,61 @@ function prepararFonteWatcher(raiz, sessionId, fonte) {
             throw e;
     }
 }
+class ErroDoApertoWatcher extends Error {
+    encerrarOutro;
+    constructor(message, encerrarOutro) {
+        super(message);
+        this.encerrarOutro = encerrarOutro;
+    }
+}
+const TETO_ABSOLUTO_APERTO_WATCHER_MS = 60000;
+const PAUSA_APERTO_WATCHER = new Int32Array(new SharedArrayBuffer(4));
+function conferirTetoDoAperto(tetoMs) {
+    if (!Number.isFinite(tetoMs) || tetoMs <= 0)
+        throw new Error('teto invalido para o aperto de mao do watcher');
+}
+/** Lado do dispatcher: lentidao nao encerra um watcher cuja identidade continua viva. */
+function esperarProntidaoWatcher(lerSinal, identidade, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => { Atomics.wait(PAUSA_APERTO_WATCHER, 0, 0, ms); });
+    const tetoProntidaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoProntidaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoProntidaoMs)
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', true);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido')
+            throw new ErroDoApertoWatcher('watcher com prontidao invalida', true);
+        if (estado(identidade) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', false);
+        const restante = tetoProntidaoMs - (agora() - inicio);
+        pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
+/** Lado do watcher: o ack continua pendente somente enquanto o pai capturado na partida nao saiu. */
+async function esperarConfirmacaoDoPaiWatcher(lerSinal, identidadePai, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const tetoConfirmacaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoConfirmacaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoConfirmacaoMs)
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido' || estado(identidadePai) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const restante = tetoConfirmacaoMs - (agora() - inicio);
+        await pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
 function iniciarWatcher(raiz, sessionId) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
@@ -947,27 +1004,29 @@ function iniciarWatcher(raiz, sessionId) {
     try {
         if (!identidade)
             throw new Error('watcher sem identidade de processo');
-        const deadline = Date.now() + 5000;
-        const pausa = new Int32Array(new SharedArrayBuffer(4));
-        while (Date.now() < deadline) {
-            const ready = lerJson(readyPath);
-            if (ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
-                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo') {
-                (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
-                    despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
-                (0, codex_runner_1.gravarAtomico)(ackPath, { token });
-                return identidade.pid;
+        esperarProntidaoWatcher(() => {
+            if (!fs.existsSync(readyPath))
+                return 'pendente';
+            let ready;
+            try {
+                ready = lerJson(readyPath);
             }
-            if ((0, codex_runner_1.estadoProcesso)(identidade) === 'ausente')
-                break;
-            Atomics.wait(pausa, 0, 0, 10);
-        }
-        throw new Error('watcher sem prontidao confirmada');
+            catch {
+                return 'invalido';
+            }
+            return ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
+                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo'
+                ? 'confirmado' : 'invalido';
+        }, identidade);
+        (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
+            despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
+        (0, codex_runner_1.gravarAtomico)(ackPath, { token });
+        return identidade.pid;
     }
     catch (e) {
         falha();
-        // Encerrar apenas o filho cuja identidade continua sendo a capturada no spawn.
-        if (identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+        // Lentidao dentro do teto nao encerra o filho; so teto ou prontidao invalida autorizam o sinal.
+        if (e instanceof ErroDoApertoWatcher && e.encerrarOutro && identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
             child.kill('SIGTERM');
         throw e;
     }
@@ -978,18 +1037,30 @@ async function acompanhar() {
     try {
         const readyPath = process.argv[5], token = process.argv[6];
         if (readyPath && token) {
+            const identidadePai = (0, codex_runner_1.identidadeProcesso)(process.ppid);
+            if (!identidadePai)
+                throw new Error('watcher sem confirmacao do pai');
             validarRegistroWatcher(carregado.raiz, sessionId);
             const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId).sessao, sessionId);
             const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
             if (!identidade)
                 throw new Error('watcher sem identidade propria');
             (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
-            const deadline = Date.now() + 5000;
-            while (lerJson(readyPath + '.ack')?.token !== token) {
-                if (Date.now() >= deadline)
-                    throw new Error('watcher sem confirmacao do pai');
-                await new Promise(r => setTimeout(r, 10));
-            }
+            await esperarConfirmacaoDoPaiWatcher(() => {
+                if (!(0, ledger_1.threadPresente)((0, thread_1.dirThread)(carregado.raiz, threadId)))
+                    return 'invalido';
+                const ackPath = readyPath + '.ack';
+                if (!fs.existsSync(ackPath))
+                    return 'pendente';
+                let ack;
+                try {
+                    ack = lerJson(ackPath);
+                }
+                catch {
+                    return 'invalido';
+                }
+                return ack?.token === token ? 'confirmado' : 'invalido';
+            }, identidadePai);
         }
         await acompanharSessao(carregado, sessionId, { threadId });
     }

package/dist/ship.js

@@ -560,7 +560,7 @@ function ship(carregado, threadId, opcoes) {
     // 3. Verificacao independente: reexecuta claims e comandos no HEAD real da thread.
     const verificacao = (0, verify_1.verificar)(carregado, threadId, { executor: opcoes.executorVerify,
         conducao: { filaPesada: { ...opcoes.avisoDaFilaPesada, esperarMs: opcoes.esperarFilaPesadaMs } } });
-    r.verificacao = verificacao;
+    r.verificacao = (0, verify_1.resultadoVerifyRedigido)(verificacao);
     if (!verificacaoCompletaParaShip(verificacao)) {
         const motivo = (verificacao.parcial ? 'verify.failed'
             : verificacao.motivos.find((m) => m !== 'claims.unverifiable'));

package/dist/temporario-das-lanes.js

@@ -0,0 +1,94 @@
+"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.ENV_TMPDIR_DA_RODADA = exports.ENV_TMPFS = void 0;
+exports.sondarTmpfs = sondarTmpfs;
+exports.selecionarTemporario = selecionarTemporario;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+exports.ENV_TMPFS = 'ORK_CHECK_TMPFS';
+/** Marca de transporte: o verify, e nao a lane, e o dono do ciclo de vida de TMPDIR. */
+exports.ENV_TMPDIR_DA_RODADA = 'ORK_CHECK_TMPDIR_DA_RODADA';
+const TMPFS_MAGIC = 0x01021994;
+/** Confere filesystem em memoria, espaco e escrita sem depender do nome ou do tamanho de uma maquina. */
+function sondarTmpfs(dir) {
+    try {
+        if (!path.isAbsolute(dir) || !fs.statSync(dir).isDirectory())
+            return { ok: false, motivo: 'candidato-ausente' };
+        const s = fs.statfsSync(dir, { bigint: true });
+        if (Number(s.type) !== TMPFS_MAGIC)
+            return { ok: false, motivo: 'filesystem-nao-e-tmpfs' };
+        const teste = fs.mkdtempSync(path.join(dir, 'ork-check-sonda-'));
+        try {
+            fs.writeFileSync(path.join(teste, 'gravavel'), 'ok', { mode: 0o600 });
+        }
+        finally {
+            fs.rmSync(teste, { recursive: true, force: true });
+        }
+        return { ok: true, livres: Number(s.bavail * s.bsize) };
+    }
+    catch (e) {
+        const erro = e;
+        return { ok: false, motivo: `sonda-falhou:${String(erro.code || erro.message)}` };
+    }
+}
+/**
+ * O tmpfs e opt-in ate a bancada provar ganho. `auto` exige folga proporcional de memoria e espaco; qualquer duvida
+ * usa o temporario em disco. Verify e lanes chamam esta mesma funcao para nao criarem politicas diferentes.
+ */
+function selecionarTemporario(opcoes = {}) {
+    const chave = opcoes.chave ?? process.env[exports.ENV_TMPFS];
+    const disco = opcoes.disco ?? os.tmpdir();
+    const candidatos = opcoes.candidatos ?? [process.env.XDG_RUNTIME_DIR, '/dev/shm']
+        .filter((x) => !!x);
+    const memoriaLivre = opcoes.memoriaLivre ?? os.freemem();
+    const memoriaTotal = opcoes.memoriaTotal ?? os.totalmem();
+    const sondar = opcoes.sondar ?? sondarTmpfs;
+    if (chave !== 'auto')
+        return { diretorio: disco, estado: 'fallback', motivo: chave ? `chave-${chave}` : 'desligado-por-padrao' };
+    if (!(memoriaTotal > 0) || memoriaLivre / memoriaTotal < 0.25) {
+        return { diretorio: disco, estado: 'fallback', motivo: 'memoria-livre-sem-folga' };
+    }
+    const necessario = Math.min(memoriaLivre / 4, memoriaTotal / 10);
+    const motivos = [];
+    for (const candidato of [...new Set(candidatos)]) {
+        const r = sondar(candidato);
+        if (r.ok && r.livres >= necessario)
+            return { diretorio: candidato, estado: 'agile', motivo: 'tmpfs-gravavel-com-folga' };
+        motivos.push(`${candidato}:${r.ok ? 'espaco-sem-folga' : r.motivo}`);
+    }
+    return { diretorio: disco, estado: 'fallback', motivo: motivos.length ? motivos.join(';') : 'sem-candidato-tmpfs' };
+}