paris-immersion 0.1.16 → 0.1.18

package/dist/commands/doctor.js

@@ -1,9 +1,14 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { homedir } from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createRequire } from 'node:module';
 import { apiAuthFetch, apiFetch, defaultApiUrl, ApiError } from '../lib/api.js';
 import { readCredentials, credentialsPath } from '../lib/credentials.js';
 import { findMarker } from '../lib/marker.js';
 import { c } from '../lib/colors.js';
+const execFileAsync = promisify(execFile);
 export async function doctorCommand(opts = {}) {
     const checks = [];
     // 1. Credentials file
@@ -44,6 +49,51 @@ export async function doctorCommand(opts = {}) {
         const settingsExists = await fs.access(settingsPath).then(() => true).catch(() => false);
         checks.push({ name: '.claude/settings.json', ok: settingsExists, detail: settingsExists ? settingsPath : 'missing — re-run `paris install`' });
     }
+    // 6. Claude Code instalado (o terminal embutido roda `claude`) — bloqueia o install.
+    let claudeInstalled = false;
+    try {
+        await execFileAsync('claude', ['--version'], { timeout: 8000 });
+        claudeInstalled = true;
+    }
+    catch {
+        claudeInstalled = false;
+    }
+    checks.push({
+        name: 'claude code',
+        ok: claudeInstalled,
+        detail: claudeInstalled ? 'instalado' : 'não instalado / fora do PATH — rode: npm i -g @anthropic-ai/claude-code',
+    });
+    // 7. Login do Claude (INFORMATIVO — o aluno loga na etapa do curso, não bloqueia install).
+    if (claudeInstalled) {
+        let loggedIn = false;
+        try {
+            const j = JSON.parse(await fs.readFile(path.join(homedir(), '.claude.json'), 'utf8'));
+            loggedIn = !!j.oauthAccount && j.hasCompletedOnboarding === true;
+        }
+        catch (e) {
+            loggedIn = e.code !== 'ENOENT';
+        }
+        checks.push({
+            name: 'claude login',
+            ok: loggedIn,
+            info: true,
+            detail: loggedIn ? 'logado' : 'ainda não logado — você loga uma vez no terminal do curso (rápido)',
+        });
+    }
+    // 8. node-pty (motor do terminal embutido) — bloqueia o install se não carrega.
+    let ptyOk = false;
+    try {
+        createRequire(import.meta.url)('node-pty');
+        ptyOk = true;
+    }
+    catch {
+        ptyOk = false;
+    }
+    checks.push({
+        name: 'node-pty',
+        ok: ptyOk,
+        detail: ptyOk ? 'ok' : 'falhou ao carregar — o terminal embutido não abre. Reinstale: npm i -g paris-immersion@latest',
+    });
     // Report
     console.log();
     console.log(c.bold('paris doctor'));
@@ -51,9 +101,9 @@ export async function doctorCommand(opts = {}) {
     console.log();
     let failures = 0;
     for (const ch of checks) {
-        const icon = ch.ok ? c.green('✓') : c.red('✗');
+        const icon = ch.ok ? c.green('✓') : ch.info ? c.yellow('○') : c.red('✗');
         console.log(`  ${icon} ${ch.name}${ch.detail ? c.dim(' — ' + ch.detail) : ''}`);
-        if (!ch.ok)
+        if (!ch.ok && !ch.info)
             failures++;
     }
     console.log();
@@ -79,8 +129,8 @@ async function reportInstallStatus(checks, token, apiUrl) {
         console.error(c.yellow('  ! --report ignorado: sem credenciais (rode `paris login`).'));
         return;
     }
-    const allOk = checks.every((c) => c.ok);
-    const failedNames = checks.filter((c) => !c.ok).map((c) => c.name);
+    const allOk = checks.filter((c) => !c.info).every((c) => c.ok);
+    const failedNames = checks.filter((c) => !c.ok && !c.info).map((c) => c.name);
     const body = {
         step: 'all',
         status: allOk ? 'ok' : 'failed',

package/dist/commands/serve.js

@@ -7,6 +7,8 @@ import { readCredentials } from '../lib/credentials.js';
 import { ensureWorkspace } from './install.js';
 import { startRelayAgent } from '../lib/relay-agent.js';
 import { renderTostudyCommand } from '../templates/tostudy-command.js';
+import { renderHookScript } from '../templates/hook.js';
+import { fileURLToPath } from 'node:url';
 import { maybeSelfUpdate } from '../lib/self-update.js';
 import { c } from '../lib/colors.js';
 /**
@@ -176,17 +178,85 @@ function ensureTostudyCommand(cwd) {
         }
     }
 }
+/**
+ * Reescreve o HOOK (`.paris/hooks/paris-hook.mjs`) e o bundle MCP vendorizado a
+ * cada serve. Crucial: o `paris install` só os escreve na CRIAÇÃO do workspace —
+ * num workspace ANTIGO (instalado antes do sync de progresso existir), o binário
+ * do CLI se auto-atualiza mas o hook fica CONGELADO e o progresso NUNCA sincroniza
+ * (gestão eterna em 0/N). Reescrever a cada serve fecha esse gap. Best-effort,
+ * idempotente (ambos são 100% auto-gerados; o settings.json aponta pro mesmo path).
+ */
+function ensureWorkspaceVendored(cwd) {
+    try {
+        const hooksDir = path.join(cwd, '.paris', 'hooks');
+        mkdirSync(hooksDir, { recursive: true });
+        writeFileSync(path.join(hooksDir, 'paris-hook.mjs'), renderHookScript(), { mode: 0o755 });
+    }
+    catch {
+        /* best-effort */
+    }
+    try {
+        const mcpSrc = fileURLToPath(new URL('../../templates/mcp/index.mjs', import.meta.url));
+        const mcpDir = path.join(cwd, '.paris', 'mcp');
+        mkdirSync(mcpDir, { recursive: true });
+        writeFileSync(path.join(mcpDir, 'index.mjs'), readFileSync(mcpSrc), { mode: 0o755 });
+    }
+    catch {
+        /* best-effort — sem o bundle, o /tostudy ainda roda; só o fallback MCP fica velho */
+    }
+}
+/**
+ * O aluno está logado no Claude Code? Checagem FILE-BASED (rápida, zero-custo) —
+ * NÃO usar `claude -p` como probe (ele trava esperando input/streama). No mac o
+ * token OAuth fica no Keychain, mas `~/.claude.json` guarda `oauthAccount` +
+ * `hasCompletedOnboarding` quando logado. Sem arquivo (ENOENT) = nunca rodou =
+ * não-logado. Arquivo ilegível por OUTRO motivo = fail-open (não bloqueia o curso).
+ */
+function isClaudeLoggedIn() {
+    try {
+        const raw = readFileSync(path.join(homedir(), '.claude.json'), 'utf8');
+        try {
+            const j = JSON.parse(raw);
+            return !!j.oauthAccount && j.hasCompletedOnboarding === true;
+        }
+        catch {
+            return true; // arquivo corrompido → não trava o curso
+        }
+    }
+    catch (e) {
+        return e.code !== 'ENOENT';
+    }
+}
 export function spawnCoachPty(cwd) {
     const req = createRequire(import.meta.url);
     ensureSpawnHelperExecutable(req);
     const ptyMod = req('node-pty');
-    // Escreve /tostudy ANTES de resolver o kickoff + subir o Claude.
+    // Escreve /tostudy + hook + MCP frescos ANTES de resolver o kickoff + subir o Claude.
     ensureTostudyCommand(cwd);
+    ensureWorkspaceVendored(cwd);
     const kickoff = resolveKickoff(cwd);
     const shell = process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : 'bash');
-    const shellArgs = process.platform === 'win32'
-        ? ['-NoLogo', '-Command', `claude "${kickoff.replace(/"/g, '`"')}"`]
-        : ['-l', '-c', `claude '${kickoff.replace(/'/g, `'\\''`)}'`];
+    // --dangerously-skip-permissions: terminal de curso CONTROLADO — sem isso o Claude
+    // pede aprovação a CADA comando (`tostudy next` etc.) e o curso trava esperando o
+    // aluno escolher "Yes/No" sem entender. Aqui o tutor (/tostudy) precisa rodar a
+    // tostudy CLI livremente; é o mesmo modo que o terminal nativo do dev usa.
+    let shellArgs;
+    if (process.platform === 'win32') {
+        shellArgs = ['-NoLogo', '-Command', `claude --dangerously-skip-permissions "${kickoff.replace(/"/g, '`"')}"`];
+    }
+    else {
+        const q = kickoff.replace(/'/g, `'\\''`);
+        // (1) Claude não instalado → mensagem clara + cai num shell (sem tela branca/erro cru).
+        const notInstalled = `if ! command -v claude >/dev/null 2>&1; then ` +
+            `printf '\\n  \\033[33m! O Claude Code nao esta instalado nesta maquina.\\033[0m\\n  Rode: \\033[1mnpm i -g @anthropic-ai/claude-code\\033[0m  e reabra a aba do curso.\\n\\n'; ` +
+            `exec bash -l; fi`;
+        // (2) Não logado → banner explicando o login (o kickoff /tostudy roda DEPOIS do
+        // login automaticamente — o Claude difere o prompt inicial até autenticar).
+        const loginBanner = isClaudeLoggedIn()
+            ? ''
+            : `printf '\\n  \\033[36mAntes do curso voce vai logar no Claude Code uma vez (e rapido):\\033[0m\\n  escolha um tema com as setas, depois Sign in with Claude, abra a URL e cole o codigo.\\n  Assim que logar, o curso comeca sozinho.\\n\\n'; `;
+        shellArgs = ['-l', '-c', `${notInstalled}\n${loginBanner}exec claude --dangerously-skip-permissions '${q}'`];
+    }
     return ptyMod.spawn(shell, shellArgs, {
         name: 'xterm-color',
         cols: 80,

package/dist/index.js

@@ -13,7 +13,7 @@ import { daemonCommand, restartCommand } from './commands/daemon.js';
 const program = new Command()
     .name('paris')
     .description('Paris Immersion — CLI do aluno (login, workspace, tarefas)')
-    .version('0.1.16');
+    .version('0.1.18');
 program
     .command('login')
     .description('Autenticar com sua conta Paris (device-code OR --token direto)')

package/dist/lib/relay-agent.js

@@ -51,12 +51,17 @@ export async function startRelayAgent(opts) {
                 headers: { authorization: `Bearer ${opts.loginToken}` },
                 signal: AbortSignal.timeout(8000),
             });
-            if (!res.ok)
-                return null;
-            return (await res.json());
+            if (res.ok)
+                return { kind: 'ok', info: (await res.json()) };
+            // 401 (JWT inválido/expirado) e 404 (participant_not_found) são definitivos:
+            // re-tentar com o mesmo loginToken nunca vai passar. 5xx é tratado como
+            // inalcançável (transitório).
+            if (res.status === 401 || res.status === 403 || res.status === 404)
+                return { kind: 'unauthorized' };
+            return { kind: 'unreachable' };
         }
         catch {
-            return null;
+            return { kind: 'unreachable' }; // DNS/timeout/conn refused — a API pode voltar
         }
     };
     // Primeira busca decide se o relay está configurado (senão → modo local-only).
@@ -65,20 +70,31 @@ export async function startRelayAgent(opts) {
     // responde 200 na 1ª tentativa). KeepAlive mantém o serve, mas sem este retry o
     // agente relay nunca subia se a 1ª busca caísse no boot.
     const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    // Mensagem acionável quando o loginToken (installer JWT ~7d) expirou ou o
+    // participante foi removido. O daemon roda detached, então isto vai pro log do
+    // launchd/systemd (pro diagnóstico) — o aluno é guiado pelo overlay do browser.
+    const RELOGIN_HINT = 'paris: login expirado — rode: npm i -g paris-immersion@latest && paris login';
     let initial = await fetchInfo();
-    for (let i = 0; i < 6 && !initial; i++) {
+    // Retry no boot SÓ enquanto a API está inalcançável (blip de rede: o daemon sobe
+    // antes da rede). Um 'unauthorized' é definitivo — não adianta re-tentar com o
+    // mesmo token; sai pro modo local-only e loga o caminho de re-login.
+    for (let i = 0; i < 6 && initial.kind === 'unreachable'; i++) {
         await sleep(5000);
         initial = await fetchInfo();
     }
-    if (!initial || !initial.relayUrl || !initial.token || !initial.e2eKeyB64)
+    if (initial.kind === 'unauthorized') {
+        log(RELOGIN_HINT);
+        return null;
+    }
+    if (initial.kind !== 'ok' || !initial.info.relayUrl || !initial.info.token || !initial.info.e2eKeyB64)
         return null;
     // Mutáveis: o serve-token é de vida curta e é RENOVADO a cada (re)conexão (o
     // loginToken/JWT do aluno é estável). Sem isso, o daemon que sobe no boot fica
     // preso com um token expirado, o relay rejeita o agente, e o terminal embutido
     // fica "Esperando o paris CLI subir" pra sempre mesmo com o serve rodando.
-    let relayUrl = initial.relayUrl;
-    let token = initial.token;
-    let key = Buffer.from(initial.e2eKeyB64, 'base64'); // chave E2E é estável por participante
+    let relayUrl = initial.info.relayUrl;
+    let token = initial.info.token;
+    let key = Buffer.from(initial.info.e2eKeyB64, 'base64'); // chave E2E é estável por participante
     if (key.length !== 32)
         return null;
     let ws = null;
@@ -152,6 +168,20 @@ export async function startRelayAgent(opts) {
         }
         catch (err) {
             log(`relay: pty spawn falhou (${err instanceof Error ? err.message : String(err)})`);
+            // Sem isto o viewer já recebeu 'agent-online' (verde "conectado") e ficaria
+            // com a TELA EM BRANCO pra sempre, sem pista. Manda um frame de texto E2E
+            // explicando + o conserto — renderiza direto no xterm do aluno.
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                const msg = '\r\n  \x1b[33m! Nao consegui abrir o terminal nesta maquina.\x1b[0m\r\n' +
+                    '  Rode no Terminal: \x1b[1mnpm i -g paris-immersion@latest && paris restart\x1b[0m\r\n' +
+                    '  Se persistir, rode o instalador de novo (a CLI pode nao ter compilado aqui).\r\n\r\n';
+                try {
+                    ws.send(seal(key, TYPE_DATA, Buffer.from(msg, 'utf8')), { binary: true });
+                }
+                catch {
+                    /* ws caiu */
+                }
+            }
             return;
         }
         pty.onData((d) => {
@@ -197,23 +227,59 @@ export async function startRelayAgent(opts) {
             }
         }, 80);
     };
+    // Backoff de reconexão. Caminho normal = 2s (rápido, pra reatachar o aluno que
+    // recarregou). Mas quando a API responde 401/404 (loginToken expirou ou
+    // participante removido), re-discar a 2s com o token velho é um loop infinito
+    // que o relay 401-a sem parar — então espaçamos pra 60s e logamos o re-login.
+    const RETRY_FAST_MS = 2000;
+    const RETRY_UNAUTH_MS = 60_000;
+    let nextRetryMs = RETRY_FAST_MS;
     const connect = async () => {
         if (closed)
             return;
         // Renova token + relayUrl + chave a cada tentativa (o serve-token expira;
         // o loginToken é estável). É isto que conserta o "agente preso no boot".
         const fresh = await fetchInfo();
-        if (fresh?.relayUrl && fresh.token && fresh.e2eKeyB64) {
-            relayUrl = fresh.relayUrl;
-            token = fresh.token;
-            const k = Buffer.from(fresh.e2eKeyB64, 'base64');
+        if (fresh.kind === 'ok' && fresh.info.relayUrl && fresh.info.token && fresh.info.e2eKeyB64) {
+            relayUrl = fresh.info.relayUrl;
+            token = fresh.info.token;
+            const k = Buffer.from(fresh.info.e2eKeyB64, 'base64');
             if (k.length === 32)
                 key = k;
+            nextRetryMs = RETRY_FAST_MS;
+        }
+        else if (fresh.kind === 'unauthorized') {
+            // Token de login morto: NÃO re-disca com o velho (o relay 401-a e o loop
+            // nunca surfacing). Loga o caminho de re-login e agenda uma tentativa
+            // espaçada — se o aluno rodar `paris login`, a próxima busca passa e reata.
+            log(RELOGIN_HINT);
+            nextRetryMs = RETRY_UNAUTH_MS;
+            if (!closed)
+                reconnect = setTimeout(connect, nextRetryMs);
+            return;
+        }
+        else {
+            // Inalcançável (rede/5xx): re-disca com o token ATUAL (pode ainda ser válido
+            // — cobre o blip de rede no boot) no ritmo rápido.
+            nextRetryMs = RETRY_FAST_MS;
         }
         if (closed)
             return;
         const url = `${relayUrl.replace(/\/$/, '')}/agent?token=${encodeURIComponent(token)}`;
         ws = new WebSocket(url);
+        // O relay rejeita o handshake (401) ANTES do upgrade quando o serve-token não
+        // valida — isso chega aqui como 'unexpected-response' (não 'open'/'close').
+        // Sem este handler o `ws` cai pra abortHandshake → error+close e re-disca a 2s.
+        // Tratamos como um sinal de re-busca: o próximo connect() chama fetchInfo() e,
+        // se a API disser 'unauthorized', o branch acima espaça/loga. O socket já está
+        // sendo abortado pelo `ws`; só registramos pra não cair no caminho silencioso.
+        ws.on('unexpected-response', (_req, res) => {
+            log(`relay: handshake rejeitado (${res.statusCode}) — re-buscando token`);
+            try {
+                res.resume();
+            }
+            catch { /* drena o corpo pra liberar o socket */ }
+        });
         ws.on('open', () => {
             // TCP_NODELAY: terminal interativo manda frames pequenos; sem isso o Nagle
             // os enfileira (~40ms/hop, pior ainda com delayed-ACK) → digitação e o 1º
@@ -291,8 +357,10 @@ export async function startRelayAgent(opts) {
         ws.on('close', () => {
             // NÃO mata o pty aqui — mantém o Claude vivo pra reatachar quando o ws
             // reconectar (o viewer-left + grace timer e o shutdown cuidam de matar).
+            // nextRetryMs = 2s no caminho normal; 60s quando a API marcou o token como
+            // morto (o connect() seguinte re-busca e re-avalia). Evita o loop 2s eterno.
             if (!closed)
-                reconnect = setTimeout(connect, 2000);
+                reconnect = setTimeout(connect, nextRetryMs);
         });
         ws.on('error', () => {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paris-immersion",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Paris Immersion CLI — login, install workspace, status, task control. Para alunos das imersões da Paris Group.",
   "homepage": "https://parisgroup.ai",
   "repository": {