paris-immersion 0.1.38 → 0.1.39

package/dist/commands/conectar.js

@@ -11,6 +11,8 @@ import { loginCommand } from './login.js';
 import { installCommand, ensureWorkspace } from './install.js';
 import { locateWorkspace } from './repair.js';
 import { maybeSelfUpdate } from '../lib/self-update.js';
+import { restartDaemon } from '../lib/daemon.js';
+import net from 'node:net';
 const execFileAsync = promisify(execFile);
 async function tokenOk() {
     try {
@@ -45,6 +47,45 @@ async function workspaceForSlug(slug) {
     }
     return null;
 }
+/**
+ * Religa o agente local (o `paris serve` que o botão do curso na War Room usa) e
+ * só aprova quando ELE disser que conectou no relay. Um agente preso com login
+ * antigo deixava a War Room em "Não achei o paris rodando" (D1 de outubro).
+ * Dentro do terminal embutido não religa: este terminal É o agente.
+ */
+async function ensureLocalAgent() {
+    if (process.env.PARIS_MCP_ENABLED === '1')
+        return { ok: true, detail: 'você já está no terminal do curso' };
+    const logFile = path.join(homedir(), '.paris', 'serve.log');
+    const offset = await fs.stat(logFile).then((s) => s.size).catch(() => 0);
+    try {
+        await restartDaemon();
+    }
+    catch (err) {
+        return { ok: false, detail: `não consegui religar o serviço: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const portOpen = () => new Promise((resolve) => {
+        const s = net.connect(31000, '127.0.0.1');
+        s.once('connect', () => { s.destroy(); resolve(true); });
+        s.once('error', () => resolve(false));
+        s.setTimeout(1000, () => { s.destroy(); resolve(false); });
+    });
+    for (let i = 0; i < 40; i++) {
+        await new Promise((r) => setTimeout(r, 750));
+        const fresh = await fs
+            .readFile(logFile)
+            .then((b) => b.subarray(offset).toString('utf8'))
+            .catch(() => '');
+        if (/relay: conectado|relay ativo/.test(fresh))
+            return { ok: true, detail: 'conectado' };
+        if (/login expirado/.test(fresh))
+            return { ok: false, detail: 'o login do agente não vale — rode `paris logout` e `paris conectar`' };
+    }
+    // Sem relay configurado (dev local) o agente só escuta a porta local.
+    return (await portOpen())
+        ? { ok: true, detail: 'rodando (sem relay)' }
+        : { ok: false, detail: 'o agente não subiu' };
+}
 async function runHookCheck(dir) {
     const hook = path.join(dir, '.paris', 'hooks', 'paris-hook.mjs');
     try {
@@ -137,7 +178,15 @@ export async function conectarCommand(opts = {}) {
         return;
     }
     console.log(c.green(`✓ Envio ok (${r.sent} evento(s) enviados${r.pending ? `, ${r.pending} ainda na fila` : ''})`));
-    // 4. Prova do lado do servidor
+    // 4. Agente local do curso (botão "abrir o curso" da War Room)
+    const agent = await ensureLocalAgent();
+    if (!agent.ok) {
+        console.log(c.red(`✗ Agente do curso: ${agent.detail}. Chame um mentor técnico.`));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(c.green(`✓ Agente do curso ${agent.detail}`));
+    // 5. Prova do lado do servidor
     try {
         const st = await apiAuthFetch('/api/activity/status/me');
         const age = st.lastActivity ? Date.now() - new Date(st.lastActivity).getTime() : Infinity;

package/dist/lib/relay-agent.d.ts

@@ -13,4 +13,8 @@ export declare function startRelayAgent(opts: {
     loginToken: string;
     cwd: string;
     log?: (msg: string) => void;
+    /** Lê o token de login atual do disco (default: ~/.paris/credentials). Teste injeta. */
+    readLoginToken?: () => Promise<string | null>;
+    /** Intervalo entre releituras do login enquanto ele está inválido (default 15s). */
+    unauthRetryMs?: number;
 }): Promise<RelayAgentHandle | null>;

package/dist/lib/relay-agent.js

@@ -39,6 +39,11 @@ function open(key, frame) {
         return null;
     }
 }
+async function defaultReadLoginToken() {
+    const { readCredentials } = await import('./credentials.js');
+    const creds = await readCredentials().catch(() => null);
+    return creds?.token ?? null;
+}
 /**
  * Inicia o agente relay. Busca o serve-token + info do relay na API (Bearer
  * creds.token), e se o relay estiver configurado, mantém a conexão wss e spawna
@@ -48,10 +53,28 @@ export async function startRelayAgent(opts) {
     if (!opts.apiUrl || !opts.loginToken)
         return null;
     const log = opts.log ?? (() => { });
+    // O loginToken NÃO é fixo: o aluno pode relogar (`paris login`/`paris conectar`)
+    // com o daemon rodando. Antes o agente guardava o token do boot pra sempre e,
+    // depois de um re-login, ficava a noite inteira em "login expirado" até alguém
+    // rodar `paris restart` (visto no D1 de outubro, 06/10 07:59). Agora, a cada
+    // 'unauthorized', ele relê ~/.paris/credentials e troca pelo token novo.
+    let loginToken = opts.loginToken;
+    const reloadLoginToken = async () => {
+        try {
+            const creds = await (opts.readLoginToken ?? defaultReadLoginToken)();
+            if (creds && creds !== loginToken) {
+                loginToken = creds;
+                log('paris: login novo detectado — reconectando');
+                return true;
+            }
+        }
+        catch { /* sem arquivo de credenciais: segue esperando */ }
+        return false;
+    };
     const fetchInfo = async () => {
         try {
             const res = await fetch(`${opts.apiUrl.replace(/\/$/, '')}/api/onboarding/v2/serve-token`, {
-                headers: { authorization: `Bearer ${opts.loginToken}` },
+                headers: { authorization: `Bearer ${loginToken}` },
                 signal: AbortSignal.timeout(8000),
             });
             if (res.ok)
@@ -85,9 +108,15 @@ export async function startRelayAgent(opts) {
         await sleep(5000);
         initial = await fetchInfo();
     }
-    if (initial.kind === 'unauthorized') {
+    // Login inválido no boot: em vez de desistir do relay (o agente ficava fora até
+    // um restart manual), espera o aluno relogar — relê o arquivo de login a cada
+    // `unauthRetryMs` e segue assim que ele mudar e a API aceitar.
+    const unauthRetryMs = opts.unauthRetryMs ?? 15_000;
+    while (initial.kind === 'unauthorized') {
         log(RELOGIN_HINT);
-        return null;
+        await sleep(unauthRetryMs);
+        await reloadLoginToken();
+        initial = await fetchInfo(); // mesmo token pode passar (ex.: participante criado depois)
     }
     if (initial.kind !== 'ok' || !initial.info.relayUrl || !initial.info.token || !initial.info.e2eKeyB64)
         return null;
@@ -255,8 +284,16 @@ export async function startRelayAgent(opts) {
             // 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.
+            // Login trocado no disco (re-login com o daemon rodando)? Usa o novo e
+            // reconecta já. Senão espaça e loga o caminho de re-login.
+            if (await reloadLoginToken()) {
+                nextRetryMs = RETRY_FAST_MS;
+                if (!closed)
+                    reconnect = setTimeout(connect, 0);
+                return;
+            }
             log(RELOGIN_HINT);
-            nextRetryMs = RETRY_UNAUTH_MS;
+            nextRetryMs = opts.unauthRetryMs ?? RETRY_UNAUTH_MS;
             if (!closed)
                 reconnect = setTimeout(connect, nextRetryMs);
             return;

package/package.json

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