@orkastery/cli 0.2.0 → 0.3.0

package/dist/mcp-ship.js

@@ -0,0 +1,436 @@
+"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.criarPerfilShipMcp = criarPerfilShipMcp;
+exports.shipMcp = shipMcp;
+/** SHIP instalado: o cliente escolhe identidade/HEADs, nunca transporte ou autorização.
+ * SSH do dono é infraestrutura confiável explícita; não é uma promessa de SSH sem helpers.
+ * Escritores hostis concorrentes fora do sandbox não pertencem a este contrato. */
+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");
+const manifest_1 = require("./manifest");
+const thread_1 = require("./thread");
+const worktree_1 = require("./worktree");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const mcp_git_1 = require("./mcp-git");
+const leases_1 = require("./leases");
+const ship_1 = require("./ship");
+const verify_1 = require("./verify");
+const claims_1 = require("./claims");
+const verify_sandbox_1 = require("./verify-sandbox");
+// Mesmo mecanismo subreaper do executor C17: também cobre Git/SSH e o worker inteiro.
+const SUPERVISOR_SHIP = String.raw `
+import ctypes, errno, json, os, selectors, signal, subprocess, sys, time
+p = json.load(sys.stdin)
+libc = ctypes.CDLL(None, use_errno=True)
+if libc.prctl(36, 1, 0, 0, 0) != 0:
+    raise OSError(ctypes.get_errno(), 'PR_SET_CHILD_SUBREAPER falhou')
+state = {'failure': None}
+def interrupted(_sig, _frame): state['failure'] = 'supervisor interrompido'
+signal.signal(signal.SIGTERM, interrupted)
+def cleanup():
+    deadline = time.monotonic() + 3
+    while True:
+        with open('/proc/self/task/' + str(os.getpid()) + '/children') as f:
+            children = [int(x) for x in f.read().split()]
+        # Filhos vivos ou zombies ainda não reaped: seus PIDs não podem ser reutilizados.
+        for pid in children:
+            try: os.kill(pid, signal.SIGKILL)
+            except ProcessLookupError: pass
+        try:
+            while True:
+                pid, _status = os.waitpid(-1, os.WNOHANG)
+                if pid == 0: break
+        except ChildProcessError: return True
+        if time.monotonic() >= deadline: return False
+        time.sleep(.005)
+stdout = bytearray(); stderr = bytearray(); code = -1
+try:
+    child = subprocess.Popen([p['bin'], *p['args']], cwd=p['cwd'], env=p['env'],
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
+    child.stdin.write(p['input'].encode()); child.stdin.close()
+    selector = selectors.DefaultSelector()
+    selector.register(child.stdout, selectors.EVENT_READ, stdout)
+    selector.register(child.stderr, selectors.EVENT_READ, stderr)
+    deadline = time.monotonic() + p['timeoutMs']/1000
+    while True:
+        if state['failure']: break
+        if time.monotonic() >= deadline:
+            state['failure'] = 'timeout do sandbox'; break
+        if child.poll() is not None and not selector.get_map():
+            code = child.returncode; break
+        for key, _ in selector.select(.025):
+            data = os.read(key.fileobj.fileno(), 65536)
+            if not data: selector.unregister(key.fileobj); continue
+            if len(stdout)+len(stderr)+len(data) > p['maxOutput']:
+                state['failure'] = 'limite de saída excedido'; break
+            key.data.extend(data)
+except Exception as e: state['failure'] = 'sandbox indisponível: ' + str(e)
+finally:
+    cleaned = cleanup()
+    if not cleaned: state['failure'] = 'descendente do sandbox não encerrou no prazo'
+print(json.dumps({'code': -1 if state['failure'] else code,
+    'stdout': stdout.decode(errors='replace'), 'stderr': stderr.decode(errors='replace'), 'failure': state['failure'], 'cleanupConfirmed': cleaned}))
+`;
+const PRAZO = 240000, RESERVA = 15000, LIMITE = 1048576;
+const perfis = new WeakMap();
+function erro(m) { throw Error('mcp.ship.' + m); }
+function digest(s) { return (0, node_crypto_1.createHash)('sha256').update(s).digest('hex'); }
+/** Somente SSH fixado/bare físico: ambos nunca usam credential helpers HTTP. HTTPS é recusado na factory. */
+function config(raiz) {
+    const raw = (0, mcp_git_1.gitPassivoMcp)(raiz, ['config', '--null', '--list']);
+    for (const item of raw.split('\0').filter(Boolean)) {
+        const i = item.indexOf('\n');
+        if (i < 0 || !(0, mcp_git_1.configuracaoPassivaGitMcp)(item.slice(0, i).toLowerCase(), item.slice(i + 1), true))
+            erro('config.unsupported');
+    }
+    return digest(raw);
+}
+/** Push usa todas as URLs configuradas; nunca fixar somente a primeira. */
+function originUnico(raiz) {
+    const ler = (push) => {
+        const raw = (0, mcp_git_1.gitPassivoMcp)(raiz, ['remote', 'get-url', ...(push ? ['--push'] : []), '--all', 'origin']);
+        const urls = raw.split('\n');
+        if (urls[urls.length - 1] === '')
+            urls.pop();
+        if (urls.length !== 1 || !urls[0] || /[\x00-\x1f\x7f]/.test(urls[0]))
+            erro('transport.urls: origin exige uma URL efetiva');
+        return urls[0];
+    };
+    const fetch = ler(false), push = ler(true);
+    if (fetch !== push)
+        erro('transport.pushurl');
+    return fetch;
+}
+function guardarBare(url) {
+    if (!path.isAbsolute(url))
+        erro('transport.bare.invalid');
+    (0, mcp_git_1.caminhoFisicoGitMcp)(url, url);
+    const st = fs.statSync(url);
+    if (st.uid !== process.getuid?.())
+        erro('transport.bare.owner');
+    for (const n of ['objects', 'refs', 'logs', 'info', 'HEAD', 'config', 'packed-refs', 'hooks'])
+        (0, mcp_git_1.metadadosGitMcp)(url, path.join(url, n));
+    const hooks = path.join(url, 'hooks');
+    if (fs.existsSync(hooks))
+        for (const n of fs.readdirSync(hooks)) {
+            if (!n.endsWith('.sample') && (fs.statSync(path.join(hooks, n)).mode & 0o111))
+                erro('transport.bare.hooks');
+        }
+    const alternates = path.join(url, 'objects/info/alternates');
+    if (fs.existsSync(alternates) && fs.statSync(alternates).size)
+        erro('transport.bare.alternates');
+    const raw = (0, mcp_git_1.gitPassivoMcp)(url, ['config', '--null', '--list']);
+    let bare = false;
+    for (const item of raw.split('\0').filter(Boolean)) {
+        const i = item.indexOf('\n'), k = item.slice(0, i).toLowerCase(), v = item.slice(i + 1);
+        if (k === 'core.bare' && v === 'true') {
+            bare = true;
+            continue;
+        }
+        if (i < 0 || !(0, mcp_git_1.configuracaoPassivaGitMcp)(k, v, true))
+            erro('transport.bare.config');
+    }
+    if (!bare)
+        erro('transport.bare.invalid');
+    return { dev: st.dev, ino: st.ino };
+}
+/** Somente instalação/startup confiável chama esta factory. O objeto é uma capacidade privada. */
+function criarPerfilShipMcp(raiz, transporte = 'github-ssh') {
+    if (process.platform !== 'linux' || !path.isAbsolute(raiz))
+        erro('project.invalid');
+    (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, raiz);
+    const c = (0, manifest_1.exigirManifesto)(raiz);
+    if (c.raiz !== raiz)
+        erro('project.invalid');
+    const destino = c.manifesto.worktree.base_branch;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(destino) || destino.includes('..') || destino.endsWith('/'))
+        erro('destination.invalid');
+    const cfg = config(raiz), url = originUnico(raiz);
+    let bare;
+    if (transporte === 'github-ssh') {
+        if (!/^git@github\.com:[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9][A-Za-z0-9._-]*\.git$/.test(url))
+            erro('transport.unsupported: GitHub SSH exigido; HTTPS requer autenticacao instalada auditada');
+    }
+    else if (transporte === 'bare-local')
+        bare = guardarBare(url);
+    else
+        erro('transport.invalid');
+    const perfil = Object.freeze({ transporte, destino }), st = fs.statSync(raiz);
+    const env = { HOME: process.env.HOME, USER: process.env.USER, LOGNAME: process.env.LOGNAME, XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        SSH_AUTH_SOCK: process.env.SSH_AUTH_SOCK, PATH: '/usr/bin:/bin', LANG: 'C.UTF-8', TMPDIR: '/tmp' };
+    perfis.set(perfil, { raiz, dev: st.dev, ino: st.ino, url, config: cfg, perfil, env, ...(bare ? { bare } : {}) });
+    return perfil;
+}
+function validar(p) {
+    if (!p || Object.keys(p).sort().join(',') !== 'expectedDestination,expectedSource,threadId' ||
+        typeof p.threadId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/.test(p.threadId) ||
+        !/^[a-f0-9]{40}$/.test(p.expectedSource) || !/^[a-f0-9]{40}$/.test(p.expectedDestination))
+        erro('request.invalid');
+}
+function gitdir(raiz, wt) {
+    if (wt === raiz)
+        return path.join(raiz, '.git');
+    const f = path.join(wt, '.git');
+    (0, mcp_git_1.caminhoFisicoGitMcp)(wt, f, true);
+    const m = /^gitdir: (.+)\s*$/.exec(fs.readFileSync(f, 'utf8'));
+    if (!m)
+        erro('worktree.invalid');
+    const d = path.resolve(wt, m[1].trim());
+    (0, mcp_git_1.caminhoFisicoGitMcp)(path.join(raiz, '.git'), d);
+    return d;
+}
+function arvore(raiz, ref) {
+    const raw = (0, mcp_git_1.gitPassivoMcp)(raiz, ['ls-tree', '-rz', ref]);
+    const nomes = [], attrs = [];
+    for (const item of raw.split('\0').filter(Boolean)) {
+        if (item.startsWith('160000 '))
+            erro('tree.gitlink.unsupported');
+        const i = item.indexOf('\t'), nome = item.slice(i + 1);
+        if (i < 0 || !nome || nomes.length >= 4096)
+            erro('tree.unsupported');
+        nomes.push(nome);
+        if (path.posix.basename(nome) === '.gitattributes')
+            attrs.push(item);
+    }
+    return { paths: nomes, attrs: attrs.sort().join('\0') };
+}
+function atributos(raiz, refs, destino) {
+    const trees = refs.map(r => arvore(raiz, r));
+    if (trees.some(t => t.attrs !== trees[0].attrs))
+        erro('attributes.transition.unsupported');
+    const nomes = [...new Set(trees.flatMap(t => t.paths))].sort();
+    if (!nomes.length || nomes.length > 4096)
+        erro('tree.unsupported');
+    const input = nomes.join('\0') + '\0';
+    const conferir = (cwd, args) => {
+        const raw = (0, mcp_git_1.gitPassivoMcp)(cwd, ['check-attr', ...args, '-z', '--stdin', 'filter', 'merge'], input), parts = raw.split('\0');
+        if (parts.pop() !== '' || parts.length !== nomes.length * 6)
+            erro('attributes.inconclusive');
+        for (let i = 0; i < nomes.length; i++) {
+            const v = parts.slice(i * 6, i * 6 + 6);
+            if (v[0] !== nomes[i] || v[1] !== 'filter' || !['unspecified', 'unset'].includes(v[2]) ||
+                v[3] !== nomes[i] || v[4] !== 'merge' || !['unspecified', 'unset', 'set', 'text', 'binary', 'union'].includes(v[5]))
+                erro('attributes.active-driver');
+        }
+    };
+    refs.forEach(r => conferir(raiz, ['--source=' + r]));
+    conferir(destino, []);
+    conferir(destino, ['--cached']);
+    // O destino não pode manter atributos locais divergentes dos blobs fixados.
+    for (const item of trees[0].attrs.split('\0').filter(Boolean)) {
+        const i = item.indexOf('\t'), nome = item.slice(i + 1), blob = item.slice(0, i).split(' ')[2], f = path.join(destino, nome);
+        (0, mcp_git_1.caminhoFisicoGitMcp)(destino, f, true);
+        const bytes = fs.readFileSync(f);
+        const hash = (0, node_crypto_1.createHash)('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+        if (hash !== blob)
+            erro('attributes.worktree.changed');
+    }
+}
+function executar(f, p) {
+    validar(p);
+    const raiz = f.raiz, deadline = Date.now() + PRAZO;
+    const guardEstado = () => {
+        (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, raiz);
+        const st = fs.statSync(raiz);
+        if (st.dev !== f.dev || st.ino !== f.ino)
+            erro('project.changed');
+        for (const dir of ['.orkastery', '.orkastery/threads', `.orkastery/threads/${p.threadId}`])
+            (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, path.join(raiz, dir));
+        (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, p.threadId);
+        for (const dir of ['.orkastery/leases', '.orkastery/tmp', '.orkastery/state-backups', '.git/worktrees']) {
+            const alvo = path.join(raiz, dir);
+            if (fs.existsSync(alvo))
+                (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, alvo);
+        }
+        (0, mcp_git_1.metadadosGitMcp)(path.join(raiz, '.orkastery'), path.join(raiz, '.orkastery/leases'));
+        (0, mcp_git_1.metadadosGitMcp)(path.join(raiz, '.orkastery'), (0, leases_1.caminhoFila)(raiz));
+    };
+    guardEstado();
+    const c = (0, manifest_1.exigirManifesto)(raiz), t = (0, thread_1.lerThread)(raiz, p.threadId), wt = t.worktree;
+    if (!wt || t.id !== p.threadId || t.status === 'fechada' || !(0, thread_1.blocoDaThread)(t, t.faseAtual).fases.includes('SHIP'))
+        erro('thread.invalid');
+    (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, wt);
+    const de = (0, worktree_1.branchDaWorktree)(t), para = f.perfil.destino;
+    if (c.manifesto.worktree.base_branch !== para)
+        erro('destination.changed');
+    // Primeira fatia requer destino já registrado: não cria checkout com attrs ainda não inspecionados.
+    const destino = (0, ship_1.arvoreComBranch)(raiz, para);
+    if (!destino)
+        erro('destination.worktree.required');
+    (0, mcp_git_1.caminhoFisicoGitMcp)(raiz, destino);
+    const refs = [p.expectedSource, p.expectedDestination, (0, mcp_git_1.gitPassivoMcp)(raiz, ['merge-base', p.expectedSource, p.expectedDestination]).trim()];
+    refs.forEach(ref => arvore(raiz, ref)); // Antes de qualquer diff, inclusive índice/WT.
+    const guard = (etapa, dir) => {
+        guardEstado();
+        if (Date.now() > deadline - RESERVA)
+            erro('deadline');
+        if (originUnico(raiz) !== f.url || config(raiz) !== f.config)
+            erro('transport.changed');
+        if (f.bare) {
+            const b = guardarBare(f.url);
+            if (b.dev !== f.bare.dev || b.ino !== f.bare.ino)
+                erro('transport.changed');
+        }
+        if ((0, mcp_git_1.gitPassivoMcp)(raiz, ['rev-parse', `refs/heads/${de}`]).trim() !== p.expectedSource || (0, mcp_git_1.gitPassivoMcp)(wt, ['rev-parse', 'HEAD']).trim() !== p.expectedSource)
+            erro('source.stale');
+        if (etapa !== 'push' && (0, mcp_git_1.gitPassivoMcp)(raiz, ['rev-parse', `refs/heads/${para}`]).trim() !== p.expectedDestination)
+            erro('destination.stale');
+        if ((0, ship_1.arvoreComBranch)(raiz, para) !== destino || (dir && dir !== destino))
+            erro('destination.changed');
+        for (const a of [wt, destino])
+            (0, mcp_git_1.perfilGitMcp)(a, path.join(raiz, '.git'), gitdir(raiz, a), t.id, []);
+        for (const a of [wt, destino])
+            if ((0, mcp_git_1.gitPassivoMcp)(a, ['diff', '--cached', '--name-only', '-z']).length || (0, mcp_git_1.gitPassivoMcp)(a, ['diff', '--name-only', '-z']).length)
+                erro('tracked.dirty');
+        atributos(raiz, refs, destino);
+    };
+    guard('inicio');
+    const comandos = (0, claims_1.lerClaims)(raiz, t.id).filter(x => x.estado !== 'retirada').flatMap(x => x.verificar).concat((0, verify_1.comandosDoManifesto)(c.manifesto).map(x => x.comando));
+    if (comandos.length > 512 || comandos.reduce((n, s) => n + Buffer.byteLength(s), 0) > LIMITE)
+        erro('verify.limit');
+    const nome = `worktree-write:${t.id}`, nomes = [nome, `path:.orkastery/threads/${t.id}`];
+    for (const n of [...nomes, 'main-tree'])
+        if (fs.lstatSync((0, leases_1.caminhoLease)(raiz, n), { throwIfNoEntry: false }) || (0, leases_1.leasesColidentes)(raiz, n).length)
+            erro('lease.busy');
+    const proprias = [];
+    const leasesIntactas = () => proprias.every(l => JSON.stringify((0, leases_1.lerLease)(raiz, l.nome)) === JSON.stringify(l));
+    try {
+        for (const n of nomes) {
+            const a = (0, leases_1.adquirirRegiao)(raiz, n, { thread: t.id, motivo: 'MCP SHIP ' + (0, node_crypto_1.randomUUID)(), ttlMs: PRAZO + RESERVA, retomarVencido: false });
+            if (!a.ok || !a.lease)
+                erro('lease.busy');
+            proprias.push(a.lease);
+        }
+        const executor = (nomeComando, comando, cwd) => {
+            guardEstado();
+            if (cwd !== wt || !leasesIntactas())
+                erro('verify.scope');
+            const restante = deadline - Date.now() - RESERVA;
+            if (restante < 100)
+                return { nome: nomeComando, comando, ok: false, code: -1, resumo: 'prazo SHIP esgotado' };
+            const sandbox = (0, verify_sandbox_1.criarExecutorSandbox)({ worktree: wt, timeoutMs: Math.min(60000, restante) });
+            try {
+                return sandbox.executar(nomeComando, comando, cwd);
+            }
+            finally {
+                sandbox.fechar();
+            }
+        };
+        return (0, ship_1.ship)(c, t.id, { de, para, remoto: 'origin', executorVerify: executor, ttlLeaseMs: PRAZO + RESERVA, retomarLeaseVencido: false,
+            revalidarGit: (etapa, dir) => { if (!leasesIntactas())
+                erro('lease.changed'); guard(etapa, dir); } });
+    }
+    finally {
+        for (const l of proprias.reverse())
+            if (JSON.stringify((0, leases_1.lerLease)(raiz, l.nome)) === JSON.stringify(l))
+                (0, leases_1.liberar)(raiz, l.nome, t.id);
+    }
+}
+/** Perfil não pode ser fabricado por argumentos JSON. Retorno interrompido exige reconciliação. */
+async function shipMcp(perfil, pedido, signal) {
+    const f = perfis.get(perfil);
+    if (!f)
+        erro('profile.invalid');
+    validar(pedido);
+    if (signal?.aborted)
+        return { ok: false, erro: 'mcp.ship.cancelled' };
+    return new Promise(resolve => {
+        const child = (0, node_child_process_1.spawn)('/usr/bin/python3', ['-c', SUPERVISOR_SHIP], { env: f.env, stdio: ['pipe', 'pipe', 'pipe'] });
+        let out = '', falhou = false, fechou = false, inicio;
+        const identity = () => { try {
+            const raw = fs.readFileSync(`/proc/${child.pid}/stat`, 'utf8');
+            return raw.slice(raw.lastIndexOf(')') + 2).split(' ')[19];
+        }
+        catch {
+            return undefined;
+        } };
+        const cancelar = () => { falhou = true; if (!fechou && inicio && identity() === inicio)
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { } };
+        const timer = setTimeout(cancelar, PRAZO + 5000);
+        signal?.addEventListener('abort', cancelar, { once: true });
+        if (signal?.aborted)
+            cancelar();
+        child.once('spawn', () => { inicio = identity(); if (!inicio || falhou) {
+            falhou = true;
+            child.stdin.end();
+            return;
+        } child.stdin.end(JSON.stringify({ bin: process.execPath, args: [__filename, '--worker'], cwd: f.raiz, env: f.env, timeoutMs: PRAZO, maxOutput: LIMITE, input: JSON.stringify({ f, pedido }) })); });
+        child.stdin.on('error', () => { falhou = true; });
+        child.on('error', () => { falhou = true; });
+        child.stdout.on('data', (b) => { if (Buffer.byteLength(out) + b.length > LIMITE * 4)
+            cancelar();
+        else
+            out += b.toString(); });
+        child.stderr.on('data', () => { falhou = true; });
+        child.on('close', (code, sig) => {
+            fechou = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', cancelar);
+            let cleanupConfirmado = false;
+            if (code === 0 && !sig)
+                try {
+                    const envelope = JSON.parse(out);
+                    cleanupConfirmado = envelope.cleanupConfirmed === true;
+                    if (!falhou && cleanupConfirmado && envelope.code === 0 && envelope.failure === null && !envelope.stderr) {
+                        const r = JSON.parse(envelope.stdout);
+                        if (typeof r.ok === 'boolean')
+                            return resolve({ ...r, cleanupConfirmado });
+                    }
+                }
+                catch { }
+            resolve({ ok: false, cleanupConfirmado, erro: 'mcp.ship.worker.incomplete: conferir processos, leases, HEAD e remoto antes de repetir' });
+        });
+    });
+}
+if (require.main === module && process.argv[2] === '--worker') {
+    try {
+        const raw = fs.readFileSync(0, 'utf8');
+        if (Buffer.byteLength(raw) > LIMITE)
+            erro('request.invalid');
+        const { f, pedido } = JSON.parse(raw);
+        const resultado = executar(f, pedido);
+        process.stdout.write(JSON.stringify({ ok: resultado.ok, resultado }));
+    }
+    catch (e) {
+        const m = e.message;
+        process.stdout.write(JSON.stringify({ ok: false, erro: m.startsWith('mcp.') ? m : 'mcp.ship.operation.failed: conferir estado antes de repetir' }));
+    }
+}

package/dist/mcp-verify.js

@@ -0,0 +1,173 @@
+"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.verificarMcp = verificarMcp;
+/** Operação estruturada: argumentos só identificam a thread; execução sempre confinada. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const manifest_1 = require("./manifest");
+const thread_1 = require("./thread");
+const claims_1 = require("./claims");
+const leases_1 = require("./leases");
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const verify_1 = require("./verify");
+const verify_sandbox_1 = require("./verify-sandbox");
+const worktree_1 = require("./worktree");
+const PRAZO_TOTAL_MS = 180_000;
+const RESERVA_MS = 10_000;
+// I-37 (D4): o teto por comando cabe o `test:ci` medido (196 s); quem limita e o prazo total.
+const COMANDO_MAX_MS = 300_000;
+const MAX_COMANDOS = 512;
+const MAX_CLAIMS = 512;
+const LIMITE_RETORNO = 40;
+function identidade(st) { return `${st.dev}:${st.ino}`; }
+function diretorioFixo(p) {
+    const real = fs.realpathSync(p);
+    if (real !== path.resolve(p) || !fs.lstatSync(p).isDirectory())
+        throw Error('mcp.verify.scope');
+    return real;
+}
+function dentro(raiz, p) { return p.startsWith(raiz + path.sep); }
+function mesmoLease(a, b) {
+    return !!a && a.nome === b.nome && a.thread === b.thread && a.pid === b.pid &&
+        a.adquiridoEm === b.adquiridoEm && a.expiraEm === b.expiraEm && a.motivo === b.motivo;
+}
+/** Síncrono: prazo total/per-command, não cancelamento reativo do event loop. */
+function verificarMcp(raizEntrada, threadId, conducao = {}) {
+    const deadline = Date.now() + PRAZO_TOTAL_MS;
+    if (!path.isAbsolute(raizEntrada) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(threadId))
+        throw Error('mcp.verify.invalid');
+    const raiz = diretorioFixo(raizEntrada);
+    const carregado = (0, manifest_1.exigirManifesto)(raiz);
+    if (fs.realpathSync(carregado.raiz) !== raiz)
+        throw Error('mcp.verify.project');
+    // Nenhum componente de estado pode redirecionar as APIs legadas que usam caminhos.
+    for (const p of [path.join(raiz, '.orkastery'), path.join(raiz, '.orkastery', 'threads'), (0, thread_1.dirThread)(raiz, threadId)]) {
+        if (!dentro(raiz, diretorioFixo(p)))
+            throw Error('mcp.verify.scope');
+    }
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+    const t = (0, thread_1.lerThread)(raiz, threadId);
+    if (t.id !== threadId || t.status === 'fechada' || !t.worktree)
+        throw Error('mcp.verify.thread');
+    const worktree = diretorioFixo(t.worktree);
+    if (!dentro(raiz, worktree))
+        throw Error('mcp.verify.worktree');
+    if (!(0, worktree_1.worktreesDoGit)(raiz).some(w => w.dir === worktree && w.branch === (0, worktree_1.branchDaWorktree)(t)))
+        throw Error('mcp.verify.worktree.unregistered');
+    const fixacaoRaiz = identidade(fs.statSync(raiz)), fixacaoWt = identidade(fs.statSync(worktree));
+    const nomes = [`worktree-write:${threadId}`, `path:.orkastery/threads/${threadId}`];
+    const leasesDir = (0, leases_1.dirLeases)(raiz);
+    const stDir = fs.lstatSync(leasesDir, { throwIfNoEntry: false });
+    if (stDir && (!stDir.isDirectory() || !dentro(raiz, diretorioFixo(leasesDir))))
+        throw Error('mcp.verify.scope');
+    const stFila = fs.lstatSync((0, leases_1.caminhoFila)(raiz), { throwIfNoEntry: false });
+    if (stFila && (!stFila.isFile() || stFila.nlink !== 1))
+        throw Error('mcp.verify.queue.unsafe');
+    // Não herda nem remove lease existente, inclusive própria, expirada ou corrompida.
+    if (nomes.some(nome => fs.lstatSync((0, leases_1.caminhoLease)(raiz, nome), { throwIfNoEntry: false }) ||
+        (0, leases_1.leasesColidentes)(raiz, nome).length) || (0, leases_1.leasesColidentes)(raiz, 'main-tree').length) {
+        throw Error('lease.busy: verificação exige leases próprias livres');
+    }
+    const tempoParaLease = deadline - Date.now();
+    if (tempoParaLease <= RESERVA_MS)
+        throw Error('mcp.verify.deadline: prazo esgotado no preflight');
+    const adquiridos = [];
+    const conservaLeases = () => adquiridos.length === nomes.length &&
+        adquiridos.every(lease => mesmoLease((0, leases_1.lerLease)(raiz, lease.nome), lease));
+    try {
+        for (const nome of nomes) {
+            const adquirido = (0, leases_1.adquirirRegiao)(raiz, nome, { thread: threadId, motivo: 'MCP VERIFY ' + (0, node_crypto_1.randomUUID)(),
+                ttlMs: tempoParaLease + RESERVA_MS, retomarVencido: false });
+            if (!adquirido.ok || !adquirido.lease)
+                throw Error('lease.busy: verificação não adquiriu região');
+            adquiridos.push(adquirido.lease);
+        }
+        (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+        const atual = (0, thread_1.lerThread)(raiz, threadId);
+        if (atual.id !== threadId || atual.status === 'fechada' || atual.worktree !== t.worktree)
+            throw Error('mcp.verify.thread.changed');
+        const claims = (0, claims_1.lerClaims)(raiz, threadId).filter(c => c.estado !== 'retirada');
+        const comandos = claims.flatMap(c => c.verificar)
+            .concat((0, verify_1.comandosDoManifesto)(carregado.manifesto).map(c => c.comando));
+        if (claims.length > MAX_CLAIMS || comandos.length > MAX_COMANDOS || comandos.reduce((n, c) => n + Buffer.byteLength(c), 0) > 1024 * 1024) {
+            throw Error('mcp.verify.limit: plano de execução excede limite');
+        }
+        const executor = (nomeComando, comando, cwd) => {
+            if (diretorioFixo(raiz) !== raiz || identidade(fs.statSync(raiz)) !== fixacaoRaiz ||
+                diretorioFixo(worktree) !== worktree || identidade(fs.statSync(worktree)) !== fixacaoWt || cwd !== worktree) {
+                throw Error('mcp.verify.scope.changed');
+            }
+            (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+            if ((0, thread_1.lerThread)(raiz, threadId).worktree !== t.worktree || !conservaLeases())
+                throw Error('mcp.verify.lease-or-scope.changed');
+            const restante = deadline - Date.now() - RESERVA_MS;
+            if (restante < 100)
+                return { nome: nomeComando, comando, ok: false, code: -1,
+                    resumo: 'não executado: prazo total de VERIFY esgotado', executado: false };
+            const prazo = Math.min(COMANDO_MAX_MS, (0, verify_1.prazoDoComando)(carregado.manifesto, nomeComando));
+            const confinado = (0, verify_sandbox_1.criarExecutorSandbox)({ worktree, timeoutMs: Math.min(prazo, restante) });
+            try {
+                const resultado = confinado.executar(nomeComando, comando, cwd);
+                if (!conservaLeases())
+                    throw Error('mcp.verify.lease.changed');
+                (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, threadId);
+                return { ...resultado, executado: true };
+            }
+            finally {
+                confinado.fechar();
+            }
+        };
+        // I-36 (T8): o MESMO lease de execucao do CLI; a sessao filha reentra pela identidade do despacho.
+        const r = (0, verify_1.verificar)(carregado, threadId, { executor, operacao: 'mcp.verify', conducao });
+        const execucoes = r.claims.flatMap(c => c.execucoes).concat(r.comandos);
+        return {
+            threadId, ok: r.ok, commit: r.commit, motivos: r.motivos,
+            claims: { total: r.claims.length, verificadas: r.claims.filter(c => c.verificado).length },
+            execucoes: execucoes.slice(0, LIMITE_RETORNO).map(c => ({ nome: c.nome, ok: c.ok, code: c.code,
+                executado: c.executado === true, resumo: c.resumo })),
+            totalExecucoes: execucoes.length, omitidas: Math.max(0, execucoes.length - LIMITE_RETORNO),
+            regressoes: r.regressoes.map(c => c.nome), preExistentes: r.preExistentes.map(c => c.nome),
+            executor: 'codex-sandbox', prazoTotalMs: PRAZO_TOTAL_MS, limitePorComandoMs: COMANDO_MAX_MS,
+        };
+    }
+    finally {
+        for (const lease of adquiridos.reverse()) {
+            if (mesmoLease((0, leases_1.lerLease)(raiz, lease.nome), lease))
+                (0, leases_1.liberar)(raiz, lease.nome, threadId);
+        }
+    }
+}