@orkastery/cli 0.2.0 → 0.3.0

package/dist/runtimes.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Registro dos runtimes de despacho homologados.
+ *
+ * O nucleo despacha fase por um runtime adapter resolvido POR NOME, e este arquivo e o
+ * domicilio unico dessa resolucao (decisao D1 da thread ork-homologarcod). Dois runtimes
+ * homologados:
+ *
+ *   claude-bg  o PADRAO, mais maduro: `claude --bg`, sessao visivel no app e em
+ *              `claude agents --json` (homologado em 02/09/2026).
+ *   codex      o segundo runtime: `codex exec` headless desanexado, sessao verificada no
+ *              rollout que o proprio Codex grava (homologado em 06/09/2026).
+ *
+ * Paridade sem downgrade: o contrato do claude-bg nao muda com a chegada do codex, e todo
+ * runtime novo entra por aqui com o MESMO contrato de despacho (dry-run, rate limit
+ * reconhecido, re-verificacao externa, nunca self-report).
+ */
+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.ORDEM_DOS_RUNTIMES = exports.RUNTIMES = exports.RUNTIME_PADRAO = void 0;
+exports.runtimeConhecido = runtimeConhecido;
+exports.resolverRuntime = resolverRuntime;
+const claudeBg = __importStar(require("./adapters/claude-bg"));
+const codex = __importStar(require("./adapters/codex"));
+const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+exports.RUNTIME_PADRAO = 'claude-bg';
+/** Phase e retry atravessam o mesmo preparo, antes de retirar segredos do filho. */
+function comRecibosPublicos(p, dispatch) {
+    if (!p.dryRun && p.vinculo) {
+        try {
+            (0, hitl_ingress_receipt_1.prepararRecibosParaDespacho)(p.contextoRuntime?.projeto ?? p.cwd, p.vinculo.thread);
+        }
+        catch {
+            return { ok: false, comando: [], sessionId: null, verificada: false,
+                stdout: '', stderr: '', erro: 'hitl.receipt.prepare-unavailable: despacho não iniciado' };
+        }
+    }
+    return dispatch(p);
+}
+exports.RUNTIMES = {
+    'claude-bg': {
+        nome: claudeBg.NOME_ADAPTER,
+        fonteVerificacao: 'claude agents --json',
+        disponivel: claudeBg.disponivel,
+        versao: claudeBg.versao,
+        montarComando: (p) => claudeBg.montarComando(p),
+        despachar: (p) => comRecibosPublicos(p, claudeBg.despachar),
+    },
+    codex: {
+        nome: codex.NOME_ADAPTER,
+        fonteVerificacao: 'rollout do codex em $CODEX_HOME/sessions',
+        disponivel: codex.disponivel,
+        versao: codex.versao,
+        montarComando: (p) => codex.montarComando(p),
+        despachar: (p) => comRecibosPublicos(p, codex.despachar),
+    },
+};
+/** Os runtimes na ordem de maturidade (o padrao primeiro). */
+exports.ORDEM_DOS_RUNTIMES = ['claude-bg', 'codex'];
+/** O nome e de um runtime homologado? */
+function runtimeConhecido(nome) {
+    return Object.prototype.hasOwnProperty.call(exports.RUNTIMES, nome);
+}
+/** Resolve o adapter pelo nome, com erro tipado quando o runtime nao existe. */
+function resolverRuntime(nome) {
+    const adapter = exports.RUNTIMES[nome];
+    if (!adapter) {
+        throw new Error(`runtime de despacho desconhecido: "${nome}" (homologados: ${exports.ORDEM_DOS_RUNTIMES.join(', ')})`);
+    }
+    return adapter;
+}

package/dist/sandbox.js

@@ -79,6 +79,15 @@ function commitar(dir, arquivo, conteudo, mensagem) {
  * proprio manifesto testa o canario, nao o produto.
  */
 function sandboxGit(nome, abbrev = 'evl') {
+    // I-49: canario nunca escreve no registro compartilhado de contas do usuario.
+    if (!process.env.ORK_CONTAS_DIR) {
+        process.env.ORK_CONTAS_DIR = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-contas-eval-')), 'private');
+    }
+    // I-51: canario nunca publica o estado da fabrica.
+    if (process.env.ORK_FABRICA_PUBLICAR === undefined)
+        process.env.ORK_FABRICA_PUBLICAR = '0';
+    if (!process.env.ORK_USUARIO_DIR)
+        process.env.ORK_USUARIO_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'ork-usuario-eval-'));
     const dir = dirTemporario(nome);
     (0, util_1.exec)('git', ['init', '-b', 'main'], dir);
     (0, util_1.exec)('git', ['config', 'user.email', 'eval@orkastery.local'], dir);

package/dist/session-events.js

@@ -0,0 +1,203 @@
+"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.TIPOS_SENSOR = exports.LIMITE_EVENTO_BYTES = void 0;
+exports.exigirSessaoDespachada = exigirSessaoDespachada;
+exports.resolverSessao = resolverSessao;
+exports.comLockDeSessao = comLockDeSessao;
+exports.ingerirEvento = ingerirEvento;
+exports.lerPayloadSensor = lerPayloadSensor;
+/** D3: o runtime observa; identidade e envelope pertencem ao ork. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const thread_1 = require("./thread");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+exports.LIMITE_EVENTO_BYTES = 16384;
+exports.TIPOS_SENSOR = ['permission_prompt', 'permission_request', 'notification',
+    'stop', 'subagent_stop', 'commit', 'heartbeat', 'resumed'];
+/**
+ * A adoção governa a identidade de uma sessão que já estava rodando e, por decisão da
+ * higiene de runtimes, não inventa data de despacho nem prompt executado. O sensor ancora
+ * no instante do despacho o dedupe do evento, o cursor por fonte e a recusa de evento
+ * anterior ao início, então a sessão adotada é recusada com correção acionável em vez de
+ * receber uma âncora fabricada a partir da adoção.
+ */
+function exigirSessaoDespachada(sessao, sessionId) {
+    if (sessao.origem === 'adocao' || typeof sessao.despachadaEm !== 'string') {
+        throw new Error(`sessão ${sessionId} foi adotada, não despachada; os sensores exigem o instante do ` +
+            'despacho: despache a fase com ork phase run para observá-la');
+    }
+    return sessao;
+}
+function resolverSessao(raiz, sessionId) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(sessionId))
+        throw new Error('sessionId inválido');
+    const achadas = (0, thread_1.listarIds)(raiz).flatMap(id => {
+        const thread = (0, thread_1.lerThread)(raiz, id);
+        return thread.sessoes.filter(s => s.sessionId === sessionId).map(sessao => ({ thread, sessao }));
+    });
+    if (achadas.length !== 1)
+        throw new Error(`sessão ${achadas.length ? 'ambígua' : 'desconhecida'}; confira ork thread status`);
+    const achada = achadas[0];
+    if (achada.thread.worktree) {
+        const estado = (0, estado_thread_1.auditarEstado)(raiz, achada.thread.id, achada.thread.worktree);
+        if (estado.nivel !== 'ok')
+            throw new Error(estado.detalhe);
+    }
+    return achada;
+}
+function validarPayload(bruto, tipo, agoraMs) {
+    if (Buffer.byteLength(bruto) > exports.LIMITE_EVENTO_BYTES)
+        throw new Error('payload excede 16384 bytes');
+    const p = JSON.parse(bruto.trim() || '{}');
+    if (!p || typeof p !== 'object' || Array.isArray(p))
+        throw new Error('payload deve ser objeto JSON');
+    const campos = ['observedAt', 'eventId', 'notificationType', 'commit'];
+    for (const [k, v] of Object.entries(p)) {
+        if (!campos.includes(k) || typeof v !== 'string')
+            throw new Error(`campo de payload inválido: ${k}`);
+    }
+    const payload = p;
+    if (payload.observedAt !== undefined && (!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(payload.observedAt) ||
+        !Number.isFinite(Date.parse(payload.observedAt)) || new Date(payload.observedAt).toISOString() !== payload.observedAt ||
+        Date.parse(payload.observedAt) > agoraMs))
+        throw new Error('observedAt inválido ou futuro');
+    if (payload.eventId !== undefined && !/^[a-zA-Z0-9._:-]{1,160}$/.test(payload.eventId))
+        throw new Error('eventId inválido');
+    if (payload.notificationType !== undefined && !['permission_prompt', 'idle_prompt', 'auth_success', 'elicitation_dialog'].includes(payload.notificationType)) {
+        throw new Error('notificationType inválido');
+    }
+    if ((tipo === 'commit' && !payload.commit) || (payload.commit !== undefined &&
+        (tipo !== 'commit' || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(payload.commit))))
+        throw new Error('commit exige SHA completo');
+    return payload;
+}
+/** Mesmo lock do carimbo HITL: pulse e hook não criam dois episódios concorrentes. */
+function comLockDeSessao(dir, executar) {
+    const lock = path.join(dir, 'ledger.jsonl.hitl-lock');
+    const dono = path.join(lock, 'pid');
+    try {
+        fs.mkdirSync(lock);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const pid = fs.existsSync(dono) ? Number(fs.readFileSync(dono, 'utf8')) : null;
+        if (pid !== null) {
+            if (!Number.isInteger(pid) || pid <= 0)
+                throw new Error('lock de sessão inválido');
+            try {
+                process.kill(pid, 0);
+                throw new Error('ingestão ocupada; tente novamente');
+            }
+            catch (erro) {
+                if (erro.code !== 'ESRCH')
+                    throw erro;
+            }
+        }
+        else if (Date.now() - fs.statSync(lock).mtimeMs < 60000)
+            throw new Error('ingestão ocupada; tente novamente');
+        fs.rmSync(dono, { force: true });
+        fs.rmdirSync(lock);
+        fs.mkdirSync(lock);
+    }
+    fs.writeFileSync(dono, String(process.pid), { flag: 'wx', mode: 0o600 });
+    try {
+        return executar();
+    }
+    finally {
+        if (fs.readFileSync(dono, 'utf8') === String(process.pid)) {
+            fs.unlinkSync(dono);
+            fs.rmdirSync(lock);
+        }
+    }
+}
+function ingerirEvento(raiz, sessionId, tipoBruto, bruto = '{}', agoraMs = Date.now()) {
+    if (!exports.TIPOS_SENSOR.includes(tipoBruto))
+        throw new Error(`tipo inválido; use ${exports.TIPOS_SENSOR.join(', ')}`);
+    const tipo = tipoBruto;
+    const payload = validarPayload(bruto, tipo, agoraMs);
+    const { thread, sessao: registrada } = resolverSessao(raiz, sessionId);
+    const sessao = exigirSessaoDespachada(registrada, sessionId);
+    const observedAt = payload.observedAt ?? new Date(agoraMs).toISOString();
+    if (Date.parse(observedAt) < Date.parse(sessao.despachadaEm))
+        throw new Error('evento anterior ao despacho');
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const bloqueio = tipo === 'permission_prompt' || tipo === 'permission_request' ||
+        (tipo === 'notification' && payload.notificationType === 'permission_prompt');
+    const retomada = tipo === 'resumed' || tipo === 'heartbeat' || tipo === 'commit';
+    const eventoTipo = bloqueio ? 'sessao_bloqueada' : tipo === 'stop' ? 'runtime_stop' :
+        tipo === 'subagent_stop' ? 'runtime_subagent_stop' : tipo === 'commit' ? 'commit' : 'runtime_event';
+    const identidade = payload.eventId ?? payload.commit ?? { ...payload, observedAt };
+    const eventId = (0, node_crypto_1.createHash)('sha256').update(JSON.stringify([sessionId, sessao.despachadaEm, tipo, identidade])).digest('hex');
+    return comLockDeSessao(dir, () => {
+        const eventos = (0, ledger_1.lerLedger)(dir);
+        if (eventos.some(e => e.sensorEventId === eventId))
+            return { gravado: false, thread: thread.id, tipo: eventoTipo, observedAt };
+        const ultimo = eventos.filter(e => e.sessionId === sessionId &&
+            ['sessao_bloqueada', 'sessao_destravada'].includes(e.tipo)).at(-1);
+        if (bloqueio && (ultimo?.tipo === 'sessao_bloqueada' || (ultimo && Date.parse(ultimo.ts) >= Date.parse(observedAt)))) {
+            return { gravado: false, thread: thread.id, tipo: eventoTipo, observedAt: ultimo.ts };
+        }
+        const dados = { ts: observedAt, fase: sessao.fase, sessionId, runtime: sessao.runtime,
+            despachoEm: sessao.despachadaEm, fonte: 'ork sessions event', sensor: tipo, sensorEventId: eventId,
+            recebidoEm: new Date(agoraMs).toISOString(), ...(payload.commit ? { commit: payload.commit } : {}),
+            // I-34: a notificação de ociosidade depois do Stop não é atividade; sem o tipo gravado,
+            // o observador claude-bg não teria como distingui-la e trataria o Stop como superado.
+            ...(tipo === 'notification' && payload.notificationType ? { notificationType: payload.notificationType } : {}),
+            ...(bloqueio ? { tipoDeHitl: 'permissao', pergunta: null, estadoRuntime: 'blocked' } : {}) };
+        if (retomada && ultimo?.tipo === 'sessao_bloqueada' && Date.parse(observedAt) > Date.parse(ultimo.ts)) {
+            (0, ledger_1.registrar)(dir, thread.id, 'sessao_destravada', { ...dados, sensorEventId: eventId + ':resume' });
+        }
+        (0, ledger_1.registrar)(dir, thread.id, eventoTipo, dados);
+        return { gravado: true, thread: thread.id, tipo: eventoTipo, observedAt };
+    });
+}
+/** Leitura limitada antes do JSON.parse, inclusive quando stdin é pipe. */
+function lerPayloadSensor(fd = 0) {
+    const buffer = Buffer.alloc(exports.LIMITE_EVENTO_BYTES + 1);
+    let total = 0;
+    while (total <= exports.LIMITE_EVENTO_BYTES) {
+        const n = fs.readSync(fd, buffer, total, buffer.length - total, null);
+        if (!n)
+            return buffer.subarray(0, total).toString('utf8');
+        total += n;
+        if (total > exports.LIMITE_EVENTO_BYTES)
+            throw new Error('payload excede 16384 bytes');
+    }
+    throw new Error('payload excede 16384 bytes');
+}