@orkastery/cli 0.6.0 → 0.6.1

package/dist/adapters/grok-mcp.js

@@ -0,0 +1,178 @@
+"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.PRAZO_DA_PARTIDA_MS = exports.ESPERA_DO_SERVIDOR_MS = exports.ENV_DO_TOKEN_DO_SERVIDOR_GROK = exports.CAMINHO_DO_SERVIDOR_GROK = exports.ENDERECO_DO_SERVIDOR_GROK = exports.CONTRATO_DO_SERVIDOR_GROK = void 0;
+exports.arquivosDoServidorGrok = arquivosDoServidorGrok;
+exports.lerJsonPequeno = lerJsonPequeno;
+exports.lerReciboServidorGrok = lerReciboServidorGrok;
+exports.iniciarServidorDoGrok = iniciarServidorDoGrok;
+/**
+ * RM-067 (F4c, thread ork-rm067f4cmcpd): o lançador do servidor MCP do `ork` da sessão filha do `grok`, fora do sandbox
+ * dele. O sandbox do `grok` vale para o processo inteiro e os filhos (G17 da RM-067): o servidor que o `grok` subia por
+ * stdio lia o estado, mas não gravava o ledger, os artefatos nem o git da worktree. Desde a F4c, o despacho sobe o servidor
+ * antes do `grok`, como processo do próprio `ork` (`grok-mcp-servidor.ts`), e o `grok` se conecta pela forma `url` do guia
+ * oficial (G16), com o token na variável do `bearer_token_env_var` (G5). Este módulo fica leve, sem o `mcp-server.ts`: o
+ * `grok.ts` o importa, e o servidor é outro arquivo, lançado por caminho como o supervisor do `codex-runner`, fora do ciclo
+ * de imports.
+ */
+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 codex_runner_1 = require("./codex-runner");
+/** O contrato do pedido e do recibo do servidor. */
+exports.CONTRATO_DO_SERVIDOR_GROK = 'ork.grok-mcp/v1';
+/** D1: só o loopback, porta efêmera, e o caminho do Streamable HTTP. */
+exports.ENDERECO_DO_SERVIDOR_GROK = '127.0.0.1';
+exports.CAMINHO_DO_SERVIDOR_GROK = '/mcp';
+/**
+ * D2 (GO-FIX 1, achado 1 da revisão): o token do despacho mora só no ambiente do servidor e no da sessão (o supervisor e o
+ * `grok`, com os filhos dele), nesta variável, que a config da worktree nomeia em `bearer_token_env_var` (G5). Num arquivo,
+ * a sessão `grok` de outra thread, que no `workspace` lê em qualquer lugar, acharia o token e a porta; o `environ` de outro
+ * processo ela não lê, porque o Landlock nega o ptrace, e a leitura do `/proc/<pid>/environ`, a quem não está num domínio
+ * aninhado ao dela. E, como a saída de uma ferramenta da sessão pode levar o token a um log, o servidor também confere que a
+ * conexão vem da árvore de processos do `grok` (GO-FIX 2, R1).
+ */
+exports.ENV_DO_TOKEN_DO_SERVIDOR_GROK = 'ORK_GROK_MCP_TOKEN';
+/** D6: quanto o despacho espera o recibo `pronto` do servidor. */
+exports.ESPERA_DO_SERVIDOR_MS = 30_000;
+/** D5: quanto o servidor espera o `.process.json` do supervisor; o pedido só o muda entre 1 s e 10 min. */
+exports.PRAZO_DA_PARTIDA_MS = 60_000;
+/** Os arquivos do servidor de um despacho, na pasta de sessões da thread, ao lado do log do supervisor. */
+function arquivosDoServidorGrok(logPath) {
+    const base = logPath.replace(/\.grok\.jsonl$/, '');
+    return { reciboPath: `${base}.grok-mcp.json`, stderrPath: `${base}.grok-mcp.log` };
+}
+const LIMITE_DO_JSON_BYTES = 65536;
+const LIMITE_DA_CAUSA = 300;
+/** JSON pequeno de um arquivo comum, sem seguir link; ausente, grande ou ilegível vira `null`. */
+function lerJsonPequeno(arquivo) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > LIMITE_DO_JSON_BYTES)
+            return null;
+        return JSON.parse(fs.readFileSync(fd, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** O recibo do servidor; outro contrato vira `null`. */
+function lerReciboServidorGrok(arquivo) {
+    const recibo = lerJsonPequeno(arquivo);
+    return recibo?.schema === exports.CONTRATO_DO_SERVIDOR_GROK ? recibo : null;
+}
+/** A última linha do stderr do servidor, curta: o motivo de ele ter saído antes de ficar pronto. */
+function causaDoStderr(arquivo) {
+    try {
+        const linhas = fs.readFileSync(arquivo, 'utf8').trim().split('\n');
+        const ultima = (linhas.at(-1) ?? '').trim().slice(0, LIMITE_DA_CAUSA);
+        return ultima ? ` (${ultima})` : '';
+    }
+    catch {
+        return '';
+    }
+}
+const pausa = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * D6: lança o servidor destacado, com o pedido por descritor anônimo e o token no ambiente, e espera o recibo `pronto`. O
+ * processo que morre antes, ou o prazo vencido, recusam com `runtime.unavailable`; no prazo vencido, o servidor é encerrado
+ * antes da recusa. O ambiente é o do filho do `grok` (o mesmo que o servidor stdio herdava), e o cwd é a worktree.
+ */
+function iniciarServidorDoGrok(pedido, cwd, env, esperaMs = exports.ESPERA_DO_SERVIDOR_MS) {
+    fs.mkdirSync(path.dirname(pedido.logPath), { recursive: true });
+    const { reciboPath, stderrPath } = arquivosDoServidorGrok(pedido.logPath);
+    const completo = { schema: exports.CONTRATO_DO_SERVIDOR_GROK, ...pedido, reciboPath };
+    const token = (0, node_crypto_1.randomBytes)(32).toString('hex');
+    // FD anônimo, como no supervisor: o pedido não fica em argv nem num arquivo persistente; ele não tem segredo.
+    const tmp = `${reciboPath}.${(0, node_crypto_1.randomUUID)()}.launch`;
+    fs.writeFileSync(tmp, JSON.stringify(completo), { flag: 'wx', mode: 0o600 });
+    const entrada = fs.openSync(tmp, 'r');
+    fs.unlinkSync(tmp);
+    let pid;
+    try {
+        // `ax`: o log nasce com o despacho e nunca segue um link deixado no lugar dele.
+        const erro = fs.openSync(stderrPath, 'ax', 0o600);
+        try {
+            const filho = (0, node_child_process_1.spawn)(process.execPath, [path.join(__dirname, 'grok-mcp-servidor.js'), '--run'], {
+                cwd, env: { ...env, [exports.ENV_DO_TOKEN_DO_SERVIDOR_GROK]: token }, detached: true, stdio: [entrada, 'ignore', erro],
+            });
+            filho.on('error', () => { });
+            filho.unref();
+            pid = filho.pid;
+        }
+        finally {
+            fs.closeSync(erro);
+        }
+    }
+    finally {
+        fs.closeSync(entrada);
+    }
+    if (!pid)
+        throw new Error('runtime.unavailable: o servidor MCP do ork para o grok nao iniciou');
+    const processo = (0, codex_runner_1.identidadeProcesso)(pid);
+    const lancado = pid;
+    const encerrar = () => {
+        if (processo && (0, codex_runner_1.estadoProcesso)(processo) === 'vivo') {
+            try {
+                process.kill(lancado, 'SIGTERM');
+            }
+            catch { /* ja saiu */ }
+        }
+    };
+    const prazo = Date.now() + esperaMs;
+    for (;;) {
+        const recibo = lerReciboServidorGrok(reciboPath);
+        if (recibo?.estado === 'pronto' && processo && recibo.processo?.pid === lancado && recibo.processo.inicio === processo.inicio)
+            return { url: recibo.url, porta: recibo.porta, token, reciboPath, processo, encerrar };
+        if (!processo || (0, codex_runner_1.estadoProcesso)(processo) === 'ausente')
+            throw new Error(`runtime.unavailable: o servidor MCP do ork para o grok saiu antes de ficar pronto${causaDoStderr(stderrPath)}`);
+        if (Date.now() >= prazo) {
+            encerrar();
+            throw new Error('runtime.unavailable: o servidor MCP do ork para o grok nao ficou pronto no prazo');
+        }
+        Atomics.wait(pausa, 0, 0, 50);
+    }
+}