paris-immersion 0.1.1 → 0.1.3

package/dist/commands/serve.d.ts

@@ -1,7 +1,32 @@
+/**
+ * Minimal pty-like interface — we type-erase node-pty so the file compiles
+ * cleanly without the native module being installed (it's loaded lazily at
+ * runtime via dynamic require).
+ */
+type IPty = {
+    write: (s: string) => void;
+    resize: (cols: number, rows: number) => void;
+    onData: (cb: (d: string) => void) => void;
+    onExit?: (cb: (e: {
+        exitCode: number;
+        signal?: number;
+    }) => void) => void;
+    kill: (signal?: string) => void;
+};
 export interface ServeOptions {
     port: number;
     allowedOrigins: string[];
+    /** The login token from ~/.paris/credentials. Accepted on the WS handshake for
+     *  backward compatibility (legacy: web sent the login token directly). */
     token: string;
+    /** API base URL — used to verify serve-tokens the browser sends (the CLI has no
+     *  JWT_SECRET, so it delegates verification to POST /api/onboarding/v2/serve-verify). */
+    apiUrl?: string;
+    /** When set, a verified serve-token must resolve to this user/participant —
+     *  read from the workspace marker so one machine's serve can't be driven by a
+     *  token minted for a different student. */
+    expectedUserId?: string;
+    expectedParticipantId?: string;
     /** Working directory the embedded `claude` runs in. Defaults to process.cwd().
      *  serveCommand sets this to the provisioned workspace so the session is coached. */
     cwd?: string;
@@ -12,6 +37,12 @@ export interface ServeHandle {
     port: number;
     close: () => void;
 }
+/**
+ * Spawn the coached pty (`claude '/tostudy'` inside the provisioned workspace).
+ * Shared by the local ws server and the relay agent. Throws if node-pty can't
+ * load/spawn — callers report it on their channel.
+ */
+export declare function spawnCoachPty(cwd: string): IPty;
 /**
  * Start a localhost WebSocket server that brokers a pty (running `claude`) to a
  * connected browser-side xterm.js. Two gates protect the channel:
@@ -32,3 +63,4 @@ export declare function readServeToken(): Promise<string>;
 export declare function serveCommand(opts: {
     port?: string | number;
 }): Promise<void>;
+export {};

package/dist/commands/serve.js

@@ -1,13 +1,100 @@
 import { WebSocketServer } from 'ws';
 import { createRequire } from 'node:module';
+import { promises as fs, chmodSync, existsSync, statSync } from 'node:fs';
+import path from 'node:path';
 import { readCredentials } from '../lib/credentials.js';
 import { ensureWorkspace } from './install.js';
+import { startRelayAgent } from '../lib/relay-agent.js';
 import { c } from '../lib/colors.js';
+/**
+ * Restore the executable bit on node-pty's `spawn-helper`. Some install paths
+ * (pnpm store hardlinks, tarball extraction without same-permissions, certain
+ * CI caches) drop the +x bit on the prebuilt helper — and without it node-pty's
+ * posix_spawnp fails at runtime with "posix_spawnp failed", killing the embedded
+ * terminal on EVERY launch. We can't depend on the package shipping it correctly,
+ * so we fix it best-effort at startup. No-op on Windows (no spawn-helper there).
+ */
+function ensureSpawnHelperExecutable(req) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        const main = req.resolve('node-pty'); // <pkg>/lib/index.js
+        const helper = path.resolve(path.dirname(main), '..', 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper');
+        if (existsSync(helper) && !(statSync(helper).mode & 0o111)) {
+            chmodSync(helper, 0o755);
+        }
+    }
+    catch {
+        /* best-effort — if we can't locate it, the spawn error path still reports cleanly */
+    }
+}
+/**
+ * Verify a serve-token the browser sent on the WS handshake. The CLI can't check
+ * the JWT signature locally (no JWT_SECRET), so it asks the API. Returns true only
+ * if the API confirms the token AND it resolves to the workspace's own student.
+ */
+async function verifyServeToken(token, opts) {
+    if (!token || !opts.apiUrl)
+        return false;
+    try {
+        const res = await fetch(`${opts.apiUrl}/api/onboarding/v2/serve-verify`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ token }),
+        });
+        if (!res.ok)
+            return false;
+        const data = (await res.json());
+        if (!data.valid)
+            return false;
+        if (opts.expectedUserId && data.userId && data.userId !== opts.expectedUserId)
+            return false;
+        if (opts.expectedParticipantId && data.participantId && data.participantId !== opts.expectedParticipantId)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 const DEFAULT_ALLOWED_ORIGINS = [
     'https://app.paris-group.com',
     'https://paris-immersion.vercel.app',
     'http://localhost:3010',
 ];
+// Initial prompt fed to `claude` when the embedded terminal opens, so the course
+// starts immediately instead of sitting at an idle prompt. Invoca a skill do
+// tutor ToStudy (`/tostudy`, do @tostudy-ai/cli) — o aluno chega aqui já logado
+// na conta dele da ToStudy (auto-login no install via cli-auth-code), então o
+// `/tostudy` roda o curso real direto. Override com PARIS_COACH_KICKOFF se uma
+// turma precisar de outro entrypoint (ex.: o tutor-paris `get_course` como
+// fallback quando não há curso ToStudy configurado).
+const COACH_KICKOFF = process.env.PARIS_COACH_KICKOFF || '/tostudy';
+/**
+ * Spawn the coached pty (`claude '/tostudy'` inside the provisioned workspace).
+ * Shared by the local ws server and the relay agent. Throws if node-pty can't
+ * load/spawn — callers report it on their channel.
+ */
+export function spawnCoachPty(cwd) {
+    const req = createRequire(import.meta.url);
+    ensureSpawnHelperExecutable(req);
+    const ptyMod = req('node-pty');
+    const shell = process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : 'bash');
+    const shellArgs = process.platform === 'win32'
+        ? ['-NoLogo', '-Command', `claude "${COACH_KICKOFF.replace(/"/g, '`"')}"`]
+        : ['-l', '-c', `claude '${COACH_KICKOFF.replace(/'/g, `'\\''`)}'`];
+    return ptyMod.spawn(shell, shellArgs, {
+        name: 'xterm-color',
+        cols: 80,
+        rows: 24,
+        cwd,
+        env: {
+            ...process.env,
+            TOSTUDY_MCP_ENABLED: '1',
+            PARIS_MCP_ENABLED: '1',
+        },
+    });
+}
 /**
  * Start a localhost WebSocket server that brokers a pty (running `claude`) to a
  * connected browser-side xterm.js. Two gates protect the channel:
@@ -33,11 +120,18 @@ export async function startServeServer(opts) {
                 return;
             }
             const url = new URL(info.req.url ?? '/', 'http://localhost');
-            if (url.searchParams.get('token') !== opts.token) {
-                cb(false, 401, 'invalid token');
+            const qToken = url.searchParams.get('token') ?? '';
+            // Fast path: the login token (creds.token) — backward compatible with
+            // older web clients that sent it directly.
+            if (qToken && qToken === opts.token) {
+                cb(true);
                 return;
             }
-            cb(true);
+            // Otherwise treat it as a serve-token (purpose 'onboarding-serve', minted by
+            // GET /api/onboarding/v2/serve-token) and let the API verify it.
+            void verifyServeToken(qToken, opts).then((ok) => {
+                cb(ok, ok ? undefined : 401, ok ? undefined : 'invalid token');
+            });
         },
     });
     // Wait for the listening event so handle.port is final (random port if 0).
@@ -51,25 +145,13 @@ export async function startServeServer(opts) {
             ws.send('READY\n');
             return;
         }
-        let pty;
+        let p;
         try {
-            // Lazy require — keeps `paris serve --help` working even if the native
-            // node-pty binary failed to compile/install on this platform.
-            const req = createRequire(import.meta.url);
-            const ptyMod = req('node-pty');
-            const shell = process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : 'bash');
-            const shellArgs = process.platform === 'win32' ? ['-NoLogo'] : ['-l', '-c', 'claude'];
-            pty = ptyMod.spawn(shell, shellArgs, {
-                name: 'xterm-color',
-                cols: 80,
-                rows: 24,
-                cwd: opts.cwd ?? process.cwd(),
-                env: {
-                    ...process.env,
-                    TOSTUDY_MCP_ENABLED: '1',
-                    PARIS_MCP_ENABLED: '1',
-                },
-            });
+            // Lazy require inside spawnCoachPty — keeps `paris serve --help` working
+            // even if the native node-pty binary failed to compile on this platform.
+            // The coach starts immediately (claude '/tostudy') so the student opens to
+            // Claude already running the course instead of an idle prompt.
+            p = spawnCoachPty(opts.cwd ?? process.cwd());
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -77,7 +159,6 @@ export async function startServeServer(opts) {
             ws.close(1011, 'pty_unavailable');
             return;
         }
-        const p = pty;
         p.onData((d) => {
             try {
                 ws.send(d);
@@ -173,9 +254,27 @@ export async function serveCommand(opts) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(c.yellow(`  ! sem workspace coachado (${msg}). Abrindo Claude em ${cwd}.`));
     }
+    // Read api_url + the workspace's owner so we can verify serve-tokens (and bind
+    // them to this student). Best-effort — falls back to login-token-only auth.
+    let apiUrl = '';
+    let expectedUserId;
+    let expectedParticipantId;
+    try {
+        const creds = await readCredentials();
+        apiUrl = creds?.api_url ?? '';
+        const markerRaw = await fs.readFile(path.join(cwd, '.paris', 'workspace.json'), 'utf8');
+        const marker = JSON.parse(markerRaw);
+        expectedUserId = marker.student_user_id;
+        expectedParticipantId = marker.participant_id;
+        if (!apiUrl && marker.api_url)
+            apiUrl = marker.api_url;
+    }
+    catch {
+        /* best-effort — verifyServeToken just no-ops without apiUrl */
+    }
     let handle;
     try {
-        handle = await startServeServer({ port: portNum, allowedOrigins, token, cwd });
+        handle = await startServeServer({ port: portNum, allowedOrigins, token, cwd, apiUrl, expectedUserId, expectedParticipantId });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -186,9 +285,32 @@ export async function serveCommand(opts) {
     console.log(c.bold('paris serve'));
     console.log(`  ${c.green('✓')} WebSocket em ${c.bold(`ws://localhost:${handle.port}`)}`);
     console.log(`  ${c.dim('origens permitidas:')} ${allowedOrigins.join(', ')}`);
+    // Relay (prod): a página em HTTPS não consegue abrir ws://localhost (mixed
+    // content / PNA), então também ficamos disponíveis via wss no relay. É
+    // best-effort: sem relay configurado na API, isto é no-op e o modo local
+    // (ws://localhost, usado pela web em http://localhost:3010) segue normal.
+    let relay = null;
+    void startRelayAgent({
+        apiUrl,
+        loginToken: token,
+        cwd,
+        log: (m) => console.log(`  ${c.dim(m)}`),
+    })
+        .then((h) => {
+        relay = h;
+        if (h)
+            console.log(`  ${c.green('✓')} relay ativo (terminal embutido funciona via HTTPS)`);
+    })
+        .catch(() => { });
     console.log(`  ${c.dim('Ctrl+C pra encerrar.')}`);
     console.log();
     const shutdown = () => {
+        try {
+            relay?.close();
+        }
+        catch {
+            /* noop */
+        }
         handle.close();
         process.exit(0);
     };

package/dist/index.js

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

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

@@ -0,0 +1,14 @@
+export interface RelayAgentHandle {
+    close: () => void;
+}
+/**
+ * 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
+ * o pty quando um viewer entra. Retorna null quando não há relay (modo local-only).
+ */
+export declare function startRelayAgent(opts: {
+    apiUrl: string;
+    loginToken: string;
+    cwd: string;
+    log?: (msg: string) => void;
+}): Promise<RelayAgentHandle | null>;

package/dist/lib/relay-agent.js

@@ -0,0 +1,193 @@
+/**
+ * Relay agent — o lado `paris serve` do terminal embutido quando a página roda
+ * em HTTPS (prod). Em vez do browser conectar `ws://localhost` (bloqueado por
+ * mixed content / PNA), o serve disca PRA FORA num relay `wss://` e o browser
+ * conecta no mesmo relay. O relay só casa a sala (= participantId) e encaminha
+ * frames BINÁRIOS cifrados E2E — nunca tem a chave.
+ *
+ * Protocolo: docs/superpowers/specs/2026-06-01-embedded-terminal-relay-e2e-design.md
+ */
+import crypto from 'node:crypto';
+import { WebSocket } from 'ws';
+import { spawnCoachPty } from '../commands/serve.js';
+const TYPE_DATA = 0x00;
+const TYPE_RESIZE = 0x01;
+/** plaintext = type(1) || body → frame = nonce(12) || AES-256-GCM(enc||tag). */
+function seal(key, type, body) {
+    const nonce = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+    const enc = Buffer.concat([cipher.update(Buffer.concat([Buffer.from([type]), body])), cipher.final()]);
+    return Buffer.concat([nonce, enc, cipher.getAuthTag()]);
+}
+function open(key, frame) {
+    try {
+        if (frame.length < 12 + 16)
+            return null;
+        const nonce = frame.subarray(0, 12);
+        const tag = frame.subarray(frame.length - 16);
+        const enc = frame.subarray(12, frame.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+        decipher.setAuthTag(tag);
+        const pt = Buffer.concat([decipher.update(enc), decipher.final()]);
+        return { type: pt[0], body: pt.subarray(1) };
+    }
+    catch {
+        return 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
+ * o pty quando um viewer entra. Retorna null quando não há relay (modo local-only).
+ */
+export async function startRelayAgent(opts) {
+    if (!opts.apiUrl || !opts.loginToken)
+        return null;
+    const log = opts.log ?? (() => { });
+    let info;
+    try {
+        const res = await fetch(`${opts.apiUrl.replace(/\/$/, '')}/api/onboarding/v2/serve-token`, {
+            headers: { authorization: `Bearer ${opts.loginToken}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return null;
+        info = (await res.json());
+    }
+    catch {
+        return null;
+    }
+    const { token, relayUrl, e2eKeyB64 } = info;
+    if (!relayUrl || !token || !e2eKeyB64)
+        return null; // relay não configurado → local-only
+    const key = Buffer.from(e2eKeyB64, 'base64');
+    if (key.length !== 32)
+        return null;
+    let ws = null;
+    let pty;
+    let closed = false;
+    let reconnect;
+    let killTimer;
+    // Mantém o Claude vivo por uma janela após o viewer sair, pra que uma
+    // reconexão (ex.: Safari derruba o ws periodicamente) REATACHE na MESMA sessão
+    // em vez de reiniciar o curso. O resize que o viewer manda ao reconectar faz a
+    // TUI do Claude repintar a tela atual.
+    const PTY_GRACE_MS = 60_000;
+    const killPty = () => {
+        if (pty) {
+            try {
+                pty.kill();
+            }
+            catch {
+                /* noop */
+            }
+            pty = undefined;
+        }
+    };
+    const startPty = () => {
+        if (pty)
+            return; // já tem Claude vivo — não reinicia (reatacha)
+        try {
+            pty = spawnCoachPty(opts.cwd);
+        }
+        catch (err) {
+            log(`relay: pty spawn falhou (${err instanceof Error ? err.message : String(err)})`);
+            return;
+        }
+        pty.onData((d) => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                try {
+                    ws.send(seal(key, TYPE_DATA, Buffer.from(d, 'utf8')), { binary: true });
+                }
+                catch {
+                    /* ws caiu no meio */
+                }
+            }
+        });
+        pty.onExit?.(() => killPty());
+    };
+    const connect = () => {
+        if (closed)
+            return;
+        const url = `${relayUrl.replace(/\/$/, '')}/agent?token=${encodeURIComponent(token)}`;
+        ws = new WebSocket(url);
+        ws.on('open', () => log(`relay: conectado (${relayUrl})`));
+        ws.on('message', (data, isBinary) => {
+            if (!isBinary) {
+                // Controle do relay (texto): viewer-joined / viewer-left.
+                try {
+                    const m = JSON.parse(data.toString());
+                    if (m.t === 'viewer-joined') {
+                        if (killTimer) {
+                            clearTimeout(killTimer);
+                            killTimer = undefined;
+                        }
+                        startPty(); // no-op se já tem Claude vivo → reatacha na mesma sessão
+                    }
+                    else if (m.t === 'viewer-left') {
+                        // Não mata na hora — janela de graça pra reconexão reatachar.
+                        if (killTimer)
+                            clearTimeout(killTimer);
+                        killTimer = setTimeout(() => {
+                            killTimer = undefined;
+                            killPty();
+                        }, PTY_GRACE_MS);
+                    }
+                }
+                catch {
+                    /* frame de controle malformado — ignora */
+                }
+                return;
+            }
+            // Frame E2E do viewer (stdin/resize) — decifra e aplica no pty.
+            const msg = open(key, data);
+            if (!msg || !pty)
+                return;
+            if (msg.type === TYPE_DATA) {
+                pty.write(msg.body.toString('utf8'));
+            }
+            else if (msg.type === TYPE_RESIZE) {
+                const [cols, rows] = msg.body.toString('utf8').split(',').map(Number);
+                if (Number.isFinite(cols) && Number.isFinite(rows)) {
+                    try {
+                        pty.resize(cols, rows);
+                    }
+                    catch {
+                        /* race de resize */
+                    }
+                }
+            }
+        });
+        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).
+            if (!closed)
+                reconnect = setTimeout(connect, 2000);
+        });
+        ws.on('error', () => {
+            try {
+                ws?.close();
+            }
+            catch {
+                /* noop */
+            }
+        });
+    };
+    connect();
+    return {
+        close: () => {
+            closed = true;
+            if (reconnect)
+                clearTimeout(reconnect);
+            if (killTimer)
+                clearTimeout(killTimer);
+            killPty();
+            try {
+                ws?.close();
+            }
+            catch {
+                /* noop */
+            }
+        },
+    };
+}

package/dist/templates/hook.js

@@ -76,9 +76,10 @@ async function main() {
     return
   }
 
-  const [workspace, current] = await Promise.all([
+  const [workspace, current, course] = await Promise.all([
     apiGet(apiUrl, '/immersion-app/v1/workspace', creds.token),
     apiGet(apiUrl, '/immersion-app/v1/missions/current', creds.token),
+    apiGet(apiUrl, '/immersion-app/v1/course', creds.token),
   ])
 
   if (!workspace) {
@@ -87,6 +88,11 @@ async function main() {
   }
   if (workspace.status === 'graduated') return
 
+  // Onboarding: enquanto o curso não termina, o terminal roda o tutor do curso
+  // (/tostudy) — isso tem prioridade sobre as missões da imersão (que nem existem
+  // na fase pre).
+  const inCourse = !!(course && course.courseCompleted === false)
+
   const lines = []
   if (PHASE === 'session-start') {
     lines.push('# Paris Immersion — contexto da sessão')
@@ -94,28 +100,40 @@ async function main() {
     lines.push('Imersão: **' + workspace.immersion.name + '** (\\'' + workspace.immersion.slug + '\\')')
     lines.push('Dia: **' + workspace.day_number + '** · fase: **' + workspace.phase + '**')
     lines.push('')
-    lines.push('Você (Claude) é o coach técnico desse aluno. Siga as regras do CLAUDE.md e da skill paris-coach. **Comece falando primeiro** com um resumo do dia e a tarefa atual — o aluno NÃO digitou nada ainda.')
-    lines.push('')
   } else {
     lines.push('# Paris — refresh de contexto')
     lines.push('')
   }
 
-  if (current && current.current) {
-    lines.push('## Tarefa atual')
-    lines.push('- **id:** \\'' + current.current.id + '\\'')
-    lines.push('- **título:** ' + current.current.title)
-    lines.push('- **tipo:** ' + current.current.deliverable_type)
-    lines.push('- **status:** ' + current.current.status)
-    if (current.current.description) lines.push('- **descrição:** ' + current.current.description)
-    if (current.current.socio_prompt) {
+  if (inCourse) {
+    lines.push('## FASE DO CURSO DE ONBOARDING')
+    lines.push('O aluno está na etapa do curso **' + course.title + '** (progresso: **' + course.lessonsCompleted + '/' + course.totalLessons + '**).')
+    lines.push('Rode a skill **/tostudy** (o tutor da ToStudy) pra conduzir o curso — o aluno já chega logado na conta dele da ToStudy (auto-login no install). NÃO trabalhe em missões da imersão enquanto o curso não terminar. (Fallback: se a ToStudy não estiver disponível, use as ferramentas MCP **get_course**/**complete_lesson** do paris.)')
+    if (PHASE === 'session-start') {
       lines.push('')
-      lines.push('### Sócio prompt')
-      lines.push(current.current.socio_prompt)
+      lines.push('**Comece falando primeiro**: rode /tostudy e dê as boas-vindas. O aluno ainda não digitou nada.')
     }
   } else {
-    lines.push('## Sem tarefa em foco')
-    lines.push('Pergunte ao aluno em que ele quer trabalhar.')
+    if (PHASE === 'session-start') {
+      lines.push('Você (Claude) é o coach técnico desse aluno. Siga as regras do CLAUDE.md e da skill paris-coach. **Comece falando primeiro** com um resumo do dia e a tarefa atual — o aluno NÃO digitou nada ainda.')
+      lines.push('')
+    }
+    if (current && current.current) {
+      lines.push('## Tarefa atual')
+      lines.push('- **id:** \\'' + current.current.id + '\\'')
+      lines.push('- **título:** ' + current.current.title)
+      lines.push('- **tipo:** ' + current.current.deliverable_type)
+      lines.push('- **status:** ' + current.current.status)
+      if (current.current.description) lines.push('- **descrição:** ' + current.current.description)
+      if (current.current.socio_prompt) {
+        lines.push('')
+        lines.push('### Sócio prompt')
+        lines.push(current.current.socio_prompt)
+      }
+    } else {
+      lines.push('## Sem tarefa em foco')
+      lines.push('Pergunte ao aluno em que ele quer trabalhar.')
+    }
   }
 
   process.stdout.write(lines.join('\\n') + '\\n')

package/dist/templates/settings.js

@@ -9,7 +9,11 @@
  */
 export function renderSettingsJson(opts) {
     return {
-        $schema: 'https://json.schemastore.org/claude-code-settings',
+        $schema: 'https://json.schemastore.org/claude-code-settings.json',
+        // Auto-confia no MCP do projeto (paris-immersion) — sem isso o Claude Code
+        // pode não conectar o server numa sessão não-interativa (terminal embutido),
+        // e o tutor abre sem as tools get_course/complete_lesson.
+        enableAllProjectMcpServers: true,
         mcpServers: {
             'paris-immersion': {
                 command: 'node',

package/package.json

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

package/templates/mcp/index.mjs

@@ -18024,6 +18024,18 @@ function buildTools() {
         transcript_excerpt: input.transcript_excerpt
       })
     },
+    {
+      name: "get_course",
+      description: "Retorna o curso de onboarding (Terminal + Claude Code): li\xE7\xF5es, objetivos e o progresso do aluno. Use NO IN\xCDCIO pra saber o que ensinar e de onde retomar.",
+      inputSchema: external_exports.object({}),
+      handler: async (_, { client }) => client.get("/immersion-app/v1/course")
+    },
+    {
+      name: "complete_lesson",
+      description: "Marca uma li\xE7\xE3o do curso de onboarding como conclu\xEDda. Progresso \xE9 MONOT\xD4NICO (nunca regride) e reconcilia com a conta ToStudy do aluno pelo e-mail. S\xD3 chame quando o aluno realmente cumprir o objetivo da li\xE7\xE3o. Quando a \xFAltima fecha, o curso conclui e a fase avan\xE7a.",
+      inputSchema: external_exports.object({ lesson_id: external_exports.string().min(1) }),
+      handler: async (input, { client }) => client.post(`/immersion-app/v1/course/lessons/${input.lesson_id}/complete`, {})
+    },
     {
       name: "reopen_task",
       description: "Reabrir uma tarefa marcada como conclu\xEDda. O aluno (voc\xEA) precisa de uma raz\xE3o.",