@orkastery/cli 0.2.0 → 0.3.0

package/dist/sessoes-adopt.js

@@ -0,0 +1,154 @@
+"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.ehRegistroDeAdocao = ehRegistroDeAdocao;
+exports.adotarSessao = adotarSessao;
+/** Adoção é registro de uma identidade existente, nunca despacho ou retomada. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const sessoes_inventario_1 = require("./sessoes-inventario");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const util_1 = require("./util");
+const pulse_delivery_1 = require("./pulse-delivery");
+/** Classificação pura: reconhece adoções legadas sem regravar seus IDs ou ledgers. */
+function ehRegistroDeAdocao(thread) {
+    return (thread.origem === 'adocao' || thread.sessoes.length > 0) &&
+        thread.sessoes.every(s => s.origem === 'adocao');
+}
+function adotarSessao(carregado, chave) {
+    if (!/^[a-f0-9-]{8,}$/i.test(chave))
+        return {
+            ok: false, criada: false, motivo: 'session.invalid', detalhe: 'use identidade exata ou prefixo de pelo menos oito caracteres',
+        };
+    const raiz = (0, estado_thread_1.raizDoEstado)(carregado.raiz);
+    const lock = path.join(raiz, '.orkastery/sessions-adopt.lock');
+    fs.mkdirSync(path.dirname(lock), { recursive: true });
+    const ocupada = { ok: false, criada: false, motivo: 'lease.busy',
+        detalhe: 'adoção em curso ou lock sem dono comprovadamente morto; preserve o lock e consulte o proprietário' };
+    // A guarda oficial serializa a recuperação; o arquivo mantém compatibilidade com adoções anteriores.
+    const guarda = (0, pulse_delivery_1.adquirirLockMonitor)(lock + '.guard');
+    if (!guarda.ok)
+        return ocupada;
+    let fd;
+    let corpo = '';
+    try {
+        try {
+            try {
+                fd = fs.openSync(lock, 'wx', 0o600);
+            }
+            catch (erro) {
+                if (erro.code !== 'EEXIST')
+                    return ocupada;
+                const antes = fs.lstatSync(lock);
+                if (!antes.isFile())
+                    return ocupada;
+                const conteudo = fs.readFileSync(lock, 'utf8');
+                const pid = JSON.parse(conteudo).pid;
+                if (!Number.isInteger(pid) || pid <= 0)
+                    return ocupada;
+                try {
+                    process.kill(pid, 0);
+                    return ocupada;
+                }
+                catch (e) {
+                    if (e.code !== 'ESRCH')
+                        return ocupada;
+                }
+                const atual = fs.lstatSync(lock);
+                if (atual.ino !== antes.ino || atual.dev !== antes.dev || fs.readFileSync(lock, 'utf8') !== conteudo)
+                    return ocupada;
+                fs.unlinkSync(lock);
+                fd = fs.openSync(lock, 'wx', 0o600);
+            }
+            corpo = JSON.stringify({ pid: process.pid, criadaEm: (0, util_1.agora)() });
+            fs.writeFileSync(fd, corpo);
+        }
+        catch {
+            return ocupada;
+        }
+        const inventario = (0, sessoes_inventario_1.inventariarSessoes)(raiz, { global: true, todas: true });
+        if (!inventario.ok)
+            return { ok: false, criada: false, motivo: 'runtime.unavailable',
+                detalhe: 'inventário incompleto ou ambíguo; consulte sessions --global --all --json' };
+        const exatas = inventario.sessoes.filter(s => s.sessionId === chave);
+        const candidatas = exatas.length ? exatas : inventario.sessoes.filter(s => s.sessionId.startsWith(chave));
+        if (candidatas.length !== 1)
+            return { ok: false, criada: false,
+                motivo: candidatas.length ? 'session.ambiguous' : 'session.missing',
+                detalhe: candidatas.length ? 'prefixo identifica mais de uma sessão' : 'identidade não encontrada no runtime' };
+        const s = candidatas[0];
+        if (s.vinculos.length === 1)
+            return { ok: true, criada: false, sessionId: s.sessionId,
+                runtime: s.runtime, vinculo: s.vinculos[0], detalhe: 'vínculo existente preservado' };
+        const assunto = 'ad' + (0, node_crypto_1.createHash)('sha256').update(s.runtime + ':' + s.sessionId).digest('hex').slice(0, 10);
+        // Preparar a thread inteira antes da gravação evita uma janela sem identidade.
+        const { thread } = (0, thread_1.novaThread)({ ...carregado, raiz }, { nome: `Sessão adotada ${s.runtime} ${s.sessionId}`,
+            assunto, modo: 'auto', dryRun: true });
+        const dir = (0, thread_1.dirThread)(raiz, thread.id);
+        if (fs.existsSync(dir))
+            return { ok: false, criada: false, motivo: 'session.conflict',
+                detalhe: 'domicílio de adoção já existe sem vínculo confirmado; preservar e reconciliar' };
+        const adotadaEm = (0, util_1.agora)();
+        thread.origem = 'adocao';
+        thread.sessoes.push({ sessionId: s.sessionId, runtime: s.runtime, slug: thread.slug,
+            fase: thread.faseAtual, bloco: 'ad-hoc', origem: 'adocao', adotadaEm, cwdOrigem: s.cwd, verificada: true });
+        (0, thread_1.gravarThread)(raiz, thread);
+        (0, ledger_1.registrar)(dir, thread.id, 'session_adopted', { sessionId: s.sessionId, runtime: s.runtime,
+            origem: 'adocao', adotadaEm, cwdOrigem: s.cwd, por: 'ork sessions adopt',
+            evidencia: inventario.fontes.filter(f => f.ok).map(f => f.origem) });
+        return { ok: true, criada: true, sessionId: s.sessionId, runtime: s.runtime,
+            vinculo: { raiz, thread: thread.id, fase: thread.faseAtual, origem: path.join(dir, 'thread.json') },
+            detalhe: 'sessão real adotada em thread ad hoc Auto' };
+    }
+    finally {
+        try {
+            if (fd !== undefined) {
+                const nosso = fs.fstatSync(fd);
+                fs.closeSync(fd);
+                if (fs.existsSync(lock)) {
+                    const atual = fs.lstatSync(lock);
+                    if (atual.ino === nosso.ino && atual.dev === nosso.dev && fs.readFileSync(lock, 'utf8') === corpo)
+                        fs.unlinkSync(lock);
+                }
+            }
+        }
+        finally {
+            guarda.liberar();
+        }
+    }
+}

package/dist/sessoes-inventario.js

@@ -0,0 +1,159 @@
+"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.inventariarSessoes = inventariarSessoes;
+/** Inventário explícito da conta atual, com fontes e vínculos verificáveis. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
+const estado_thread_1 = require("./estado-thread");
+const thread_1 = require("./thread");
+/** Projeto canônico mais próximo de cada cwd declarado, sem varrer o HOME inteiro. */
+function raizesDeRegistros(cwds) {
+    const raizes = new Set();
+    const ancestrais = new Set();
+    for (const cwd of cwds) {
+        let dir = path.resolve(cwd);
+        let encontrou = false;
+        for (;;) {
+            if (fs.existsSync(dir)) {
+                const canonica = (0, estado_thread_1.raizDoEstado)(dir);
+                if (fs.existsSync(path.join(canonica, '.orkastery', 'threads'))) {
+                    if (encontrou)
+                        ancestrais.add(canonica);
+                    else
+                        raizes.add(canonica);
+                    encontrou = true;
+                }
+            }
+            const pai = path.dirname(dir);
+            if (pai === dir)
+                break;
+            dir = pai;
+        }
+    }
+    return { raizes: [...raizes].sort(),
+        ancestraisPendentes: [...ancestrais].filter(r => !raizes.has(r)).sort() };
+}
+function inventariarSessoes(raiz, opcoes = {}) {
+    const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+    const claude = (0, claude_bg_1.consultarSessoes)(undefined, opcoes.todas);
+    const codex = (0, codex_1.consultarRollouts)(opcoes.todas);
+    const fontes = [
+        { origem: `claude agents --json${opcoes.todas ? ' --all' : ''}`, ok: claude.ok, detalhe: claude.detalhe },
+        ...codex.resultadosFontes,
+    ];
+    const todas = [
+        ...claude.sessoes.map(s => ({ ...s, runtime: 'claude-bg', vinculos: [] })),
+        ...codex.sessoes.map(s => ({ ...s, runtime: 'codex', vinculos: [] })),
+    ];
+    // O cruzamento usa o universo global mesmo quando a apresentação é local.
+    try {
+        const projetos = raizesDeRegistros([canonica, ...todas.map(s => s.cwd)]);
+        // Não abrir registros de um hospedeiro apenas por ancestralidade. Sem consultá-lo,
+        // porém, não podemos descartar vínculos: a fonte pendente impede um falso zero global.
+        // Se outro cwd declarar esse projeto, ele entra normalmente em projetos.raizes.
+        for (const projeto of projetos.ancestraisPendentes) {
+            fontes.push({ origem: path.join(projeto, '.orkastery/threads'), ok: false,
+                detalhe: 'projeto ancestral não consultado; vínculos globais incompletos' });
+        }
+        for (const projeto of projetos.raizes) {
+            const fonte = { origem: path.join(projeto, '.orkastery/threads'), ok: true, detalhe: '' };
+            fontes.push(fonte);
+            try {
+                for (const id of (0, thread_1.listarIds)(projeto)) {
+                    try {
+                        const t = (0, thread_1.lerThread)(projeto, id);
+                        // O site também usa thread.json para recibos de entrega, sem registro de runtime.
+                        // Reconhecer o schema explícito não autoriza ignorar threads corrompidas.
+                        if (t.schema === 'site-delivery/v1' &&
+                            !('sessoes' in t)) {
+                            fontes.push({ origem: path.join(fonte.origem, id, 'thread.json'), ok: true,
+                                detalhe: 'site-delivery/v1: recibo de entrega, sem contrato de registro de sessões' });
+                            continue;
+                        }
+                        if (t.id !== id || !Array.isArray(t.sessoes))
+                            throw new Error('registro inválido');
+                        for (const s of t.sessoes) {
+                            if (!s || typeof s.sessionId !== 'string' || s.sessionId.length < 8)
+                                throw new Error('identidade inválida');
+                            const runtime = s.runtime ?? 'claude-bg';
+                            const candidatas = todas.filter(v => v.runtime === runtime &&
+                                (v.sessionId === s.sessionId || v.sessionId.startsWith(s.sessionId)));
+                            if (candidatas.length > 1)
+                                throw new Error('prefixo ambíguo');
+                            if (candidatas.length === 1) {
+                                const v = candidatas[0];
+                                if (!v.vinculos.some(r => r.raiz === projeto && r.thread === id)) {
+                                    v.vinculos.push({ raiz: projeto, thread: id, fase: s.fase, origem: path.join(projeto, '.orkastery/threads', id, 'thread.json') });
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        fonte.ok = false;
+                        fonte.detalhe = 'inventário parcial de registros; consulte os arquivos com erro';
+                        fontes.push({ origem: path.join(fonte.origem, id, 'thread.json'), ok: false,
+                            detalhe: 'registro de thread ilegível, inválido ou identidade ambígua' });
+                    }
+                }
+            }
+            catch {
+                fonte.ok = false;
+                fonte.detalhe = 'registro de thread ilegível, inválido ou identidade ambígua';
+            }
+        }
+    }
+    catch {
+        fontes.push({ origem: 'projetos dos cwds', ok: false, detalhe: 'não foi possível consultar os registros acessíveis' });
+    }
+    const sessoes = opcoes.global ? todas : todas.filter(s => {
+        try {
+            return (0, estado_thread_1.raizDoEstado)(s.cwd) === canonica || s.cwd === canonica || s.cwd.startsWith(canonica + path.sep);
+        }
+        catch {
+            return false;
+        }
+    });
+    const ambiguas = sessoes.filter(s => s.vinculos.length > 1).length;
+    return {
+        ok: fontes.every(f => f.ok) && ambiguas === 0,
+        escopo: { usuario: os.userInfo().username, global: !!opcoes.global, historico: !!opcoes.todas, raiz: canonica },
+        fontes, sessoes, total: sessoes.length,
+        semThread: sessoes.filter(s => s.vinculos.length === 0).length, ambiguas,
+    };
+}

package/dist/sessoes.js

@@ -39,49 +39,30 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.textoDoInventario = textoDoInventario;
 exports.tabelaDeSessoes = tabelaDeSessoes;
 exports.logsDaSessao = logsDaSessao;
 exports.pararSessao = pararSessao;
 exports.comandoDeAttach = comandoDeAttach;
 const adapter = __importStar(require("./adapters/claude-bg"));
-const thread_1 = require("./thread");
+const sessoes_inventario_1 = require("./sessoes-inventario");
 const util_1 = require("./util");
-/** Tabela das sessoes vivas, cruzada com as sessoes registradas nas threads. */
-function tabelaDeSessoes(raiz, todas = false) {
-    const vivas = adapter.listarSessoes(raiz, todas);
-    const registradas = new Map();
-    for (const id of (0, thread_1.listarIds)(raiz)) {
-        const t = (0, thread_1.lerThread)(raiz, id);
-        for (const s of t.sessoes) {
-            registradas.set(s.sessionId, { thread: t.id, slug: s.slug, fase: s.fase });
-        }
-    }
-    const linhas = [];
-    const dados = vivas.map((s) => {
-        const reg = registradas.get(s.sessionId);
-        return [
-            (s.id ?? s.sessionId).slice(0, 8),
-            s.name ?? '(sem nome)',
-            s.kind ?? '?',
-            s.state ?? s.status ?? '?',
-            reg ? `${reg.thread}/${reg.fase}` : '(fora do ork)',
-        ];
-    });
-    linhas.push(dados.length === 0
-        ? 'Nenhuma sessao ativa sob a raiz do projeto.'
-        : (0, util_1.tabela)(['ID', 'NOME', 'TIPO', 'ESTADO', 'THREAD/FASE'], dados));
-    const idsVivos = new Set(vivas.map((s) => s.sessionId));
-    const sumidas = [...registradas.entries()].filter(([id]) => !idsVivos.has(id));
-    if (sumidas.length > 0) {
-        linhas.push('');
-        linhas.push('Sessoes registradas na thread que nao aparecem no runtime agora:');
-        for (const [id, reg] of sumidas) {
-            linhas.push(`  ${id.slice(0, 8)}  ${reg.slug}  ${reg.thread}/${reg.fase}`);
-        }
-        linhas.push('  (use --all para incluir sessoes ja concluidas)');
-    }
+function textoDoInventario(r) {
+    const linhas = [
+        `Inventário ${r.escopo.global ? 'global' : 'do projeto'} da conta ${r.escopo.usuario}; histórico: ${r.escopo.historico ? 'incluído' : 'omitido'}.`,
+        `Fontes: ${r.fontes.map(f => `${f.origem} (${f.ok ? 'ok' : 'FALHA'})`).join('; ')}`,
+        `Total: ${r.total}; sem thread: ${r.semThread}; ambíguas: ${r.ambiguas}; consulta: ${r.ok ? 'válida' : 'INCOMPLETA'}.`,
+    ];
+    if (r.sessoes.length)
+        linhas.push((0, util_1.tabela)(['ID', 'RUNTIME', 'ESTADO', 'THREAD/FASE'], r.sessoes.map(s => [s.sessionId, s.runtime, s.state ?? s.status ?? 'unknown',
+            s.vinculos.map(v => `${v.thread}/${v.fase}`).join(', ') || '(fora do ork)'])));
+    for (const f of r.fontes.filter(f => !f.ok))
+        linhas.push(`Falha: ${f.detalhe}`);
     return linhas.join('\n');
 }
+function tabelaDeSessoes(raiz, todas = false) {
+    return textoDoInventario((0, sessoes_inventario_1.inventariarSessoes)(raiz, { todas }));
+}
 /** Logs de uma sessao pelo id curto, id completo ou nome. */
 function logsDaSessao(chave, linhas) {
     const r = adapter.logs(chave, linhas);