paris-immersion 0.1.17 → 0.1.19

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

@@ -205,6 +205,28 @@ function ensureWorkspaceVendored(cwd) {
         /* 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);
@@ -214,9 +236,27 @@ export function spawnCoachPty(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/commands/tostudy-login.d.ts

@@ -0,0 +1,19 @@
+export type TostudyLoginOptions = {
+    /** Re-loga mesmo se já houver sessão (default: respeita a sessão existente). */
+    force?: boolean;
+    /** Silencia o passo-a-passo (usado quando chamado de dentro do curso). */
+    quiet?: boolean;
+};
+/**
+ * Conecta o ToStudy CLI à conta da imersão — a rede de segurança quando o
+ * auto-login do install falhou (tipicamente a provisão ainda estava pendente:
+ * ela é async, então no install o code volta 409 e o login não acontece; aqui,
+ * no momento de abrir o curso, ela já costuma ter terminado).
+ *
+ * REGRA do produto: se o aluno JÁ tem sessão ToStudy (a conta dele), NÃO
+ * mexemos — o curso da imersão entra nela via claim-by-email. Só logamos via
+ * code quando NÃO há sessão (ou com --force).
+ *
+ * NUNCA loga o `code` (é single-use, efêmero) — só o resultado.
+ */
+export declare function tostudyLoginCommand(opts?: TostudyLoginOptions): Promise<void>;

package/dist/commands/tostudy-login.js

@@ -0,0 +1,101 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readCredentials } from '../lib/credentials.js';
+import { apiFetch, defaultApiUrl, ApiError } from '../lib/api.js';
+import { c } from '../lib/colors.js';
+const execFileAsync = promisify(execFile);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** `tostudy courses` exit 0 = sessão ToStudy válida nesta máquina. */
+async function tostudyAuthed() {
+    try {
+        await execFileAsync('tostudy', ['courses'], { timeout: 12000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Conecta o ToStudy CLI à conta da imersão — a rede de segurança quando o
+ * auto-login do install falhou (tipicamente a provisão ainda estava pendente:
+ * ela é async, então no install o code volta 409 e o login não acontece; aqui,
+ * no momento de abrir o curso, ela já costuma ter terminado).
+ *
+ * REGRA do produto: se o aluno JÁ tem sessão ToStudy (a conta dele), NÃO
+ * mexemos — o curso da imersão entra nela via claim-by-email. Só logamos via
+ * code quando NÃO há sessão (ou com --force).
+ *
+ * NUNCA loga o `code` (é single-use, efêmero) — só o resultado.
+ */
+export async function tostudyLoginCommand(opts = {}) {
+    const log = (s) => { if (!opts.quiet)
+        console.log(s); };
+    const creds = await readCredentials().catch(() => null);
+    if (!creds) {
+        console.error(c.red('Não logado no paris. Rode `paris login` primeiro.'));
+        process.exitCode = 1;
+        return;
+    }
+    if (!opts.force && (await tostudyAuthed())) {
+        log(c.green('ToStudy já está conectado — o curso da imersão usa essa conta.'));
+        return;
+    }
+    // Mintar o code single-use. A provisão é async: enquanto pendente, a rota
+    // responde 409 (tostudy_provision_pending) e dispara a provisão em background
+    // — re-tentamos até o code sair (ou esgotar). 404 = sem participante (bail).
+    let code = '';
+    let apiUrl = '';
+    for (let i = 0; i < 8; i++) {
+        try {
+            const r = await apiFetch('/api/onboarding/v2/tostudy-cli-code', {
+                method: 'POST',
+                body: {},
+                token: creds.token,
+                apiUrl: creds.api_url ?? defaultApiUrl(),
+            });
+            code = r.code;
+            apiUrl = r.apiUrl;
+            break;
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 404) {
+                console.error(c.yellow('Sem participante ativo nesta conta — nada pra conectar.'));
+                process.exitCode = 1;
+                return;
+            }
+            const transient = e instanceof ApiError && (e.status === 409 || e.status >= 500);
+            if (!transient && i === 0) {
+                // Erro inesperado logo de cara — não fica martelando.
+                console.error(c.yellow('Não consegui preparar o acesso ao ToStudy agora. Rode `tostudy login` ou avise a equipe.'));
+                process.exitCode = 1;
+                return;
+            }
+            if (i < 7) {
+                log(c.dim(`preparando seu acesso ao ToStudy… (${i + 1}/8)`));
+                await sleep(4000);
+            }
+        }
+    }
+    if (!code || !apiUrl) {
+        console.error(c.yellow('Seu curso ainda está sendo preparado. Tente de novo em ~1 min — se persistir, avise a equipe da imersão.'));
+        process.exitCode = 1;
+        return;
+    }
+    // Logout primeiro garante que a sessão da imersão entre limpa (a sessão é
+    // global, uma conta por vez). Best-effort.
+    try {
+        await execFileAsync('tostudy', ['logout'], { timeout: 12000 });
+    }
+    catch { /* sem sessão prévia: ok */ }
+    try {
+        await execFileAsync('tostudy', ['login', '--code', code, '--api-url', apiUrl], { timeout: 20000 });
+    }
+    catch { /* o verify abaixo decide */ }
+    if (await tostudyAuthed()) {
+        log(c.green('✓ ToStudy conectado à conta da imersão. Reabra o curso.'));
+    }
+    else {
+        console.error(c.yellow('Não consegui conectar o ToStudy automaticamente. Rode `tostudy login` manualmente e reabra o curso.'));
+        process.exitCode = 1;
+    }
+}

package/dist/index.js

@@ -10,10 +10,11 @@ import { graduateCommand } from './commands/graduate.js';
 import { logoutCommand } from './commands/logout.js';
 import { serveCommand } from './commands/serve.js';
 import { daemonCommand, restartCommand } from './commands/daemon.js';
+import { tostudyLoginCommand } from './commands/tostudy-login.js';
 const program = new Command()
     .name('paris')
     .description('Paris Immersion — CLI do aluno (login, workspace, tarefas)')
-    .version('0.1.17');
+    .version('0.1.19');
 program
     .command('login')
     .description('Autenticar com sua conta Paris (device-code OR --token direto)')
@@ -65,6 +66,11 @@ program
     .command('restart')
     .description('Religa o agente do terminal embutido (libera a porta + reinicia o serviço). Use se o terminal não conectar.')
     .action(restartCommand);
+program
+    .command('tostudy-login')
+    .description('Conecta o ToStudy CLI à conta da imersão (rede de segurança quando o curso não abre). Respeita sessão existente.')
+    .option('--force', 'Re-loga mesmo se já houver sessão ToStudy')
+    .action(tostudyLoginCommand);
 program.parseAsync().catch((err) => {
     console.error('\n[paris] erro:', err?.message ?? err);
     process.exit(1);

package/dist/lib/relay-agent.js

@@ -168,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) => {

package/dist/templates/tostudy-command.js

@@ -12,7 +12,13 @@ export function renderTostudyCommand() {
 description: Inicia ou retoma o curso de onboarding da imersão (tutor ToStudy no terminal)
 ---
 
-Você é o **tutor do curso de onboarding** da imersão Paris Group, rodando no terminal do aluno. Conduza o curso da ToStudy em **português**, no ritmo do aluno. O aluno já chega logado na conta dele da ToStudy (auto-login no install).
+Você é o **tutor do curso de onboarding** da imersão Paris Group, rodando no terminal do aluno. Conduza o curso da ToStudy em **português**, no ritmo do aluno.
+
+## 0. Garanta o acesso ao ToStudy (em silêncio, ANTES de tudo)
+
+1. Rode \`tostudy courses --json\`. Se listar o curso, siga para o passo 1.
+2. Se der **erro de autenticação / "não autenticado"**, rode \`paris tostudy-login\` (conecta a conta da imersão; é normal a primeira vez, porque a matrícula é preparada em segundo plano). Depois rode \`tostudy courses --json\` de novo.
+3. Se mesmo assim continuar sem curso, avise o aluno **uma vez**, gentil: "Seu curso ainda está sendo preparado — tente reabrir em 1 minuto, ou avise a equipe da imersão." e use o fallback do passo 3 (MCP). Nunca trave nem fique em loop.
 
 ## 1. Prepare o curso (em silêncio, antes de falar)
 

package/package.json

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