paris-immersion 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# paris-immersion
+
+CLI dos alunos da **Paris Immersion** — login, instalação do workspace da imersão, controle de tarefas e diagnóstico de ambiente.
+
+```bash
+npm i -g paris-immersion
+# ou
+pnpm add -g paris-immersion
+# ou
+yarn global add paris-immersion
+```
+
+## Como começar
+
+Depois de instalar, você terá o comando `paris` disponível no terminal.
+
+```bash
+paris login        # Autentica via device-code flow (abre o browser pra confirmar)
+paris install      # Cria o workspace da sua imersão na pasta atual
+paris status       # Vê em qual fase você está + tarefa em foco
+paris tasks        # Lista as tarefas do dia
+paris doctor       # Diagnostica credentials, marker, hooks, conectividade
+```
+
+## Fluxo do aluno
+
+1. **Login** — `paris login` abre uma URL com um código tipo `ABCD-1234`. Você acessa, confirma no painel Paris Immersion (já logado com sua conta) e o CLI fica autenticado.
+2. **Install** — `paris install` baixa templates e configura o Claude Code pra te guiar pela imersão usando o **Sócio** (IA da Paris).
+3. **Durante a imersão** — Cada tarefa do dia tem um Sócio dedicado que te ajuda. Marque conclusões com `paris tasks`.
+4. **Reabrir tarefa** — `paris reopen <mission-id>` se precisar retomar algo.
+5. **Graduate** — `paris graduate` quando concluir a imersão.
+
+## Comandos
+
+| Comando | O que faz |
+|---|---|
+| `paris login` | Autentica com sua conta Paris (device-code flow) |
+| `paris install` | Instala o workspace da imersão na pasta atual |
+| `paris doctor` | Diagnostica credentials, marker, hooks, conectividade |
+| `paris tasks` | Lista tarefas do dia (CLI-only, não abre Claude) |
+| `paris status` | Resumo da fase atual + tarefa em foco |
+| `paris reopen <id>` | Reabre uma tarefa marcada como concluída |
+| `paris graduate` | Marca a imersão como concluída |
+| `paris logout` | Remove credenciais locais |
+
+## Suporte
+
+Em caso de problemas, rode `paris doctor` e mande o output pro time da Paris.
+
+— Paris Group · [parisgroup.ai](https://parisgroup.ai)

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+export type DoctorOptions = {
+    /** When set, posts a summary of the run to /api/onboarding/v2/install-status for the onboarding wizard. */
+    report?: boolean;
+};
+export declare function doctorCommand(opts?: DoctorOptions): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,104 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+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';
+export async function doctorCommand(opts = {}) {
+    const checks = [];
+    // 1. Credentials file
+    const creds = await readCredentials().catch(() => null);
+    if (!creds) {
+        checks.push({ name: 'credentials', ok: false, detail: `not found at ${credentialsPath()} — run \`paris login\`` });
+    }
+    else {
+        checks.push({ name: 'credentials', ok: true, detail: `logged in as ${creds.email}` });
+    }
+    // 2. API reachable + token still valid
+    if (creds) {
+        try {
+            const workspace = await apiAuthFetch('/immersion-app/v1/workspace');
+            checks.push({ name: 'api / token', ok: true, detail: `${workspace.immersion.name} · ${workspace.phase} · day ${workspace.day_number} (${workspace.status})` });
+        }
+        catch (err) {
+            checks.push({
+                name: 'api / token',
+                ok: false,
+                detail: err instanceof ApiError ? `${err.status} ${err.message}` : String(err),
+            });
+        }
+    }
+    // 3. Workspace marker
+    const found = await findMarker();
+    if (!found) {
+        checks.push({ name: 'workspace marker', ok: false, detail: 'no .paris/workspace.json walking up from cwd — run `paris install` here' });
+    }
+    else {
+        checks.push({ name: 'workspace marker', ok: true, detail: `${path.join(found.dir, '.paris/workspace.json')}` });
+        // 4. Hooks present
+        const hookPath = path.join(found.dir, '.paris', 'hooks', 'paris-hook.mjs');
+        const hookExists = await fs.access(hookPath).then(() => true).catch(() => false);
+        checks.push({ name: 'paris-hook.mjs', ok: hookExists, detail: hookExists ? hookPath : 'missing — re-run `paris install --dir <here>`' });
+        // 5. .claude/settings.json
+        const settingsPath = path.join(found.dir, '.claude', 'settings.json');
+        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`' });
+    }
+    // Report
+    console.log();
+    console.log(c.bold('paris doctor'));
+    console.log(c.dim(`API: ${creds?.api_url ?? defaultApiUrl()}`));
+    console.log();
+    let failures = 0;
+    for (const ch of checks) {
+        const icon = ch.ok ? c.green('✓') : c.red('✗');
+        console.log(`  ${icon} ${ch.name}${ch.detail ? c.dim(' — ' + ch.detail) : ''}`);
+        if (!ch.ok)
+            failures++;
+    }
+    console.log();
+    if (failures === 0) {
+        console.log(c.green('Tudo certo.'));
+    }
+    else {
+        console.log(c.yellow(`${failures} problema(s) encontrados.`));
+        process.exitCode = 1;
+    }
+    if (opts.report) {
+        await reportInstallStatus(checks, creds?.token, creds?.api_url);
+    }
+}
+/**
+ * POST /api/onboarding/v2/install-status — used by Phase 3 of the onboarding
+ * wizard to flip install_completed_at when every check passes, or stash a
+ * blocked-signal when something failed. Best-effort: a failed report is logged
+ * to stderr but never raises (the doctor output is the real signal to the user).
+ */
+async function reportInstallStatus(checks, token, apiUrl) {
+    if (!token) {
+        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 body = {
+        step: 'all',
+        status: allOk ? 'ok' : 'failed',
+        os: process.platform,
+        arch: process.arch,
+        detail: failedNames.length ? `failed: ${failedNames.join(',')}` : undefined,
+    };
+    try {
+        await apiFetch('/api/onboarding/v2/install-status', {
+            method: 'POST',
+            body,
+            token,
+            apiUrl: apiUrl ?? defaultApiUrl(),
+        });
+        console.log(c.dim(`  → reported install-status=${body.status} to api`));
+    }
+    catch (err) {
+        const msg = err instanceof ApiError ? `${err.status} ${err.message}` : (err instanceof Error ? err.message : String(err));
+        console.error(c.yellow(`  ! falha ao enviar install-status: ${msg}`));
+    }
+}

package/dist/commands/graduate.d.ts

@@ -0,0 +1 @@
+export declare function graduateCommand(): Promise<void>;

package/dist/commands/graduate.js

@@ -0,0 +1,13 @@
+import { apiAuthFetch } from '../lib/api.js';
+import { c } from '../lib/colors.js';
+export async function graduateCommand() {
+    const res = await apiAuthFetch('/immersion-app/v1/graduate', {
+        method: 'POST',
+    });
+    if (res.status === 'already_graduated') {
+        console.log(c.yellow(`Já estava graduado em ${res.graduated_at.slice(0, 10)}.`));
+    }
+    else {
+        console.log(c.green(`✓ Graduado em ${res.graduated_at.slice(0, 10)}. Hooks ficam silenciosos a partir da próxima sessão.`));
+    }
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,4 @@
+export declare function installCommand(opts: {
+    dir?: string;
+    immersion?: string;
+}): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,88 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { apiAuthFetch } from '../lib/api.js';
+import { findMarker, writeMarker } from '../lib/marker.js';
+import { readCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+import { renderClaudeMd } from '../templates/claude-md.js';
+import { renderSettingsJson } from '../templates/settings.js';
+import { renderParisCoachSkill } from '../templates/skill.js';
+import { renderHookScript } from '../templates/hook.js';
+export async function installCommand(opts) {
+    const creds = await readCredentials();
+    if (!creds) {
+        throw new Error('Você precisa rodar `paris login` antes.');
+    }
+    // Refuse to re-install on top of an existing marker without -d <new path>.
+    const existing = await findMarker();
+    if (existing && !opts.dir) {
+        console.log(c.yellow(`Marker já existe em ${existing.dir}.`));
+        console.log(c.dim('Use `paris doctor` pra validar, ou passe --dir <novo-path> pra criar outro workspace.'));
+        return;
+    }
+    process.stdout.write(c.dim('Buscando contexto da imersão...\n'));
+    const slugQuery = opts.immersion ? `?immersion=${encodeURIComponent(opts.immersion)}` : '';
+    const boot = await apiAuthFetch(`/immersion-app/v1/workspace/bootstrap${slugQuery}`, {
+        method: 'POST',
+    });
+    const targetDir = path.resolve(opts.dir ?? `paris-${boot.immersion.slug}`);
+    await fs.mkdir(targetDir, { recursive: true });
+    // .paris/workspace.json — the marker.
+    await writeMarker(targetDir, { ...boot.marker, api_url: creds.api_url });
+    // .paris/hooks/paris-hook.mjs — installed Claude Code hook.
+    const hooksDir = path.join(targetDir, '.paris', 'hooks');
+    await fs.mkdir(hooksDir, { recursive: true });
+    await fs.writeFile(path.join(hooksDir, 'paris-hook.mjs'), renderHookScript(), { mode: 0o755 });
+    // .paris/mcp/index.mjs — vendored, self-contained MCP server bundle. Shipped
+    // inside this package (templates/mcp/index.mjs) and copied verbatim so the
+    // workspace needs no npm install and no npx fetch at session start.
+    const mcpDir = path.join(targetDir, '.paris', 'mcp');
+    await fs.mkdir(mcpDir, { recursive: true });
+    await fs.writeFile(path.join(mcpDir, 'index.mjs'), await readVendoredMcpBundle(), { mode: 0o755 });
+    // .claude/settings.json — wires hooks + MCP server.
+    const claudeDir = path.join(targetDir, '.claude');
+    await fs.mkdir(claudeDir, { recursive: true });
+    // Write both settings.json (so the regular interactive `claude` picks it up)
+    // and settings.local.json (so `claude -p` does too — in -p mode, local
+    // settings are the reliably-loaded source for hooks).
+    const settingsPayload = renderSettingsJson({ apiUrl: creds.api_url });
+    await fs.writeFile(path.join(claudeDir, 'settings.json'), JSON.stringify(settingsPayload, null, 2));
+    await fs.writeFile(path.join(claudeDir, 'settings.local.json'), JSON.stringify(settingsPayload, null, 2));
+    // .claude/skills/paris-coach/SKILL.md
+    const skillDir = path.join(claudeDir, 'skills', 'paris-coach');
+    await fs.mkdir(skillDir, { recursive: true });
+    await fs.writeFile(path.join(skillDir, 'SKILL.md'), renderParisCoachSkill());
+    // CLAUDE.md — workspace-level rules.
+    await fs.writeFile(path.join(targetDir, 'CLAUDE.md'), renderClaudeMd({
+        immersionName: boot.immersion.name,
+        immersionSlug: boot.immersion.slug,
+        participantEmail: creds.email,
+    }));
+    console.log();
+    console.log(c.green(`✓ Workspace pronto em ${targetDir}`));
+    console.log();
+    console.log(c.bold('Próximo passo:'));
+    console.log(`  cd ${path.relative(process.cwd(), targetDir) || '.'}`);
+    console.log('  claude');
+    console.log();
+    console.log(c.dim(`Imersão: ${boot.immersion.name} · fase ${boot.phase} · dia ${boot.day_number}`));
+}
+/**
+ * Reads the bundled MCP server shipped with this package. Lives at
+ * `<pkg>/templates/mcp/index.mjs` — same relative location from both the
+ * compiled `dist/commands/install.js` and the dev `src/commands/install.ts`.
+ * Built by `scripts/build-mcp-bundle.mjs` (runs in the `build` script before
+ * publish). If it's missing the build is broken — fail loud rather than ship a
+ * workspace whose Claude session has no coach tools.
+ */
+async function readVendoredMcpBundle() {
+    const bundlePath = fileURLToPath(new URL('../../templates/mcp/index.mjs', import.meta.url));
+    try {
+        return await fs.readFile(bundlePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`MCP bundle não encontrado em ${bundlePath}. ` +
+            'Build incompleto — rode `pnpm --filter paris-immersion build` (que gera o bundle) antes de publicar.');
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,4 @@
+export declare function loginCommand(opts: {
+    apiUrl?: string;
+    token?: string;
+}): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,101 @@
+import { hostname, platform } from 'node:os';
+import { setTimeout as delay } from 'node:timers/promises';
+import { apiFetch, ApiError, defaultApiUrl } from '../lib/api.js';
+import { writeCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+export async function loginCommand(opts) {
+    const apiUrl = opts.apiUrl ?? defaultApiUrl();
+    // --token: skip device-code flow. Usado pelo installer (PARIS_ONBOARDING_TOKEN
+    // env mintado pelo wizard /api/onboarding/v2/installer-token).
+    // Valida o token contra /auth/me antes de persistir.
+    if (opts.token) {
+        process.stdout.write(c.dim(`Validando token via ${apiUrl}...\n`));
+        try {
+            const me = await apiFetch('/auth/me', {
+                method: 'GET',
+                apiUrl,
+                token: opts.token,
+            });
+            await writeCredentials({
+                token: opts.token,
+                user_id: me.id,
+                email: me.email,
+                api_url: apiUrl,
+                obtained_at: new Date().toISOString(),
+            });
+            console.log(c.green(`✓ Autenticado como ${me.email}.`));
+            console.log(c.dim('  Token salvo em ~/.paris/credentials.'));
+            return;
+        }
+        catch (err) {
+            const msg = err instanceof ApiError ? `${err.status} ${err.message}` : String(err);
+            throw new Error(`Login falhou (token inválido ou expirado): ${msg}`);
+        }
+    }
+    process.stdout.write(c.dim(`Conectando a ${apiUrl}...\n`));
+    const start = await apiFetch('/auth/cli/start', {
+        method: 'POST',
+        apiUrl,
+        body: {
+            client_info: {
+                hostname: safeHostname(),
+                platform: platform(),
+                cli_version: '0.1.0',
+            },
+        },
+    });
+    console.log();
+    console.log(c.bold('Para autorizar o CLI, abra:'));
+    console.log('  ' + c.cyan(start.verification_uri));
+    console.log();
+    console.log(c.bold('Confirme que o código abaixo aparece na página:'));
+    console.log('  ' + c.green(c.bold(start.user_code)));
+    console.log();
+    console.log(c.dim(`Esse código expira em ${Math.floor(start.expires_in / 60)} minutos.`));
+    console.log(c.dim('Aguardando aprovação...'));
+    console.log();
+    const deadline = Date.now() + start.expires_in * 1000;
+    let intervalMs = start.interval * 1000;
+    while (Date.now() < deadline) {
+        await delay(intervalMs);
+        try {
+            const poll = await apiFetch('/auth/cli/poll', {
+                method: 'POST',
+                apiUrl,
+                body: { device_code: start.device_code },
+            });
+            if (poll.status === 'approved') {
+                await writeCredentials({
+                    token: poll.token,
+                    user_id: poll.user.id,
+                    email: poll.user.email,
+                    api_url: apiUrl,
+                    obtained_at: new Date().toISOString(),
+                });
+                console.log(c.green(`✓ Autenticado como ${poll.user.email}.`));
+                console.log(c.dim(`  Token salvo em ~/.paris/credentials.`));
+                return;
+            }
+            if (poll.status === 'authorization_pending') {
+                // Honor server-suggested cadence.
+                intervalMs = poll.interval * 1000;
+                continue;
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiError && (err.status === 410 || err.status === 404)) {
+                throw new Error(`Login falhou: ${err.message}`);
+            }
+            throw err;
+        }
+    }
+    throw new Error('Login expirou. Rode `paris login` de novo.');
+}
+function safeHostname() {
+    try {
+        return hostname();
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logoutCommand(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,20 @@
+import { apiAuthFetch } from '../lib/api.js';
+import { deleteCredentials, readCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+export async function logoutCommand() {
+    const creds = await readCredentials();
+    if (!creds) {
+        console.log(c.dim('Nenhuma sessão local pra encerrar.'));
+        return;
+    }
+    // Best-effort server-side revocation. If it fails (offline, server down) we
+    // still wipe the local credentials so the user isn't stranded.
+    try {
+        await apiAuthFetch('/auth/logout', { method: 'POST', body: {} });
+    }
+    catch {
+        // ignore
+    }
+    await deleteCredentials();
+    console.log(c.green('✓ Logout completo.'));
+}

package/dist/commands/reopen.d.ts

@@ -0,0 +1,3 @@
+export declare function reopenCommand(missionId: string, opts: {
+    reason?: string;
+}): Promise<void>;

package/dist/commands/reopen.js

@@ -0,0 +1,9 @@
+import { apiAuthFetch } from '../lib/api.js';
+import { c } from '../lib/colors.js';
+export async function reopenCommand(missionId, opts) {
+    const res = await apiAuthFetch(`/immersion-app/v1/missions/${missionId}/reopen`, {
+        method: 'POST',
+        body: { reason: opts.reason ?? 'student reopen' },
+    });
+    console.log(c.green(`✓ Reaberta: ${res.mission_id}`));
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,31 @@
+export interface ServeOptions {
+    port: number;
+    allowedOrigins: string[];
+    token: string;
+    /** When true, accept connections without spawning a pty — used by tests + dry-run handshake checks. */
+    dryRun?: boolean;
+}
+export interface ServeHandle {
+    port: number;
+    close: () => void;
+}
+/**
+ * Start a localhost WebSocket server that brokers a pty (running `claude`) to a
+ * connected browser-side xterm.js. Two gates protect the channel:
+ *
+ *  1. Origin header must be in `allowedOrigins`. Browsers always set Origin on
+ *     WS handshakes, so a same-origin web page can connect but a script from
+ *     evil.com can't.
+ *  2. `?token=...` query param must match `opts.token`. The token is the
+ *     value persisted in ~/.paris/credentials at `paris login` time.
+ *
+ * The server binds to 127.0.0.1 only — never 0.0.0.0 — so it's invisible on
+ * the LAN. xterm.js still reaches it because `ws://localhost` is a secure
+ * context per W3C Secure Contexts spec, even from an https:// page.
+ */
+export declare function startServeServer(opts: ServeOptions): Promise<ServeHandle>;
+/** Read the bearer token used by the web client to authenticate against `paris serve`. */
+export declare function readServeToken(): Promise<string>;
+export declare function serveCommand(opts: {
+    port?: string | number;
+}): Promise<void>;

package/dist/commands/serve.js

@@ -0,0 +1,180 @@
+import { WebSocketServer } from 'ws';
+import { createRequire } from 'node:module';
+import { readCredentials } from '../lib/credentials.js';
+import { c } from '../lib/colors.js';
+const DEFAULT_ALLOWED_ORIGINS = [
+    'https://app.paris-group.com',
+    'https://paris-immersion.vercel.app',
+    'http://localhost:3010',
+];
+/**
+ * Start a localhost WebSocket server that brokers a pty (running `claude`) to a
+ * connected browser-side xterm.js. Two gates protect the channel:
+ *
+ *  1. Origin header must be in `allowedOrigins`. Browsers always set Origin on
+ *     WS handshakes, so a same-origin web page can connect but a script from
+ *     evil.com can't.
+ *  2. `?token=...` query param must match `opts.token`. The token is the
+ *     value persisted in ~/.paris/credentials at `paris login` time.
+ *
+ * The server binds to 127.0.0.1 only — never 0.0.0.0 — so it's invisible on
+ * the LAN. xterm.js still reaches it because `ws://localhost` is a secure
+ * context per W3C Secure Contexts spec, even from an https:// page.
+ */
+export async function startServeServer(opts) {
+    const wss = new WebSocketServer({
+        port: opts.port,
+        host: '127.0.0.1',
+        verifyClient: (info, cb) => {
+            const origin = info.origin ?? '';
+            if (!opts.allowedOrigins.includes(origin)) {
+                cb(false, 403, 'origin not allowed');
+                return;
+            }
+            const url = new URL(info.req.url ?? '/', 'http://localhost');
+            if (url.searchParams.get('token') !== opts.token) {
+                cb(false, 401, 'invalid token');
+                return;
+            }
+            cb(true);
+        },
+    });
+    // Wait for the listening event so handle.port is final (random port if 0).
+    await new Promise((resolve, reject) => {
+        wss.once('listening', () => resolve());
+        wss.once('error', reject);
+    });
+    wss.on('connection', (ws) => {
+        if (opts.dryRun) {
+            // Tests use this branch — we just confirm the handshake passed.
+            ws.send('READY\n');
+            return;
+        }
+        let pty;
+        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: process.cwd(),
+                env: {
+                    ...process.env,
+                    TOSTUDY_MCP_ENABLED: '1',
+                    PARIS_MCP_ENABLED: '1',
+                },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ws.send(`ERROR: pty spawn failed: ${msg}\n`);
+            ws.close(1011, 'pty_unavailable');
+            return;
+        }
+        const p = pty;
+        p.onData((d) => {
+            try {
+                ws.send(d);
+            }
+            catch {
+                // ws may already be closed mid-write — pty.kill on close cleans up
+            }
+        });
+        if (p.onExit) {
+            p.onExit(() => {
+                try {
+                    ws.close(1000, 'pty_exited');
+                }
+                catch {
+                    /* noop */
+                }
+            });
+        }
+        ws.on('message', (m) => {
+            const s = m.toString();
+            if (s.startsWith('RESIZE:')) {
+                const [cols, rows] = s.slice('RESIZE:'.length).split(',').map(Number);
+                if (Number.isFinite(cols) && Number.isFinite(rows)) {
+                    try {
+                        p.resize(cols, rows);
+                    }
+                    catch {
+                        /* ignore resize race */
+                    }
+                }
+                return;
+            }
+            p.write(s);
+        });
+        ws.on('close', () => {
+            try {
+                p.kill();
+            }
+            catch {
+                /* noop */
+            }
+        });
+    });
+    const addr = wss.address();
+    const port = typeof addr === 'object' && addr ? addr.port : opts.port;
+    return {
+        port,
+        close: () => {
+            for (const client of wss.clients) {
+                try {
+                    client.terminate();
+                }
+                catch {
+                    /* noop */
+                }
+            }
+            wss.close();
+        },
+    };
+}
+/** Read the bearer token used by the web client to authenticate against `paris serve`. */
+export async function readServeToken() {
+    const creds = await readCredentials().catch(() => null);
+    if (!creds)
+        return '';
+    return creds.token ?? '';
+}
+export async function serveCommand(opts) {
+    const token = await readServeToken();
+    if (!token) {
+        console.error(c.red('Não logado.') + ' Rode: ' + c.bold('paris login'));
+        process.exit(1);
+    }
+    const portNum = opts.port == null ? 31000 : Number(opts.port);
+    if (!Number.isFinite(portNum) || portNum < 0 || portNum > 65535) {
+        console.error(c.red(`Porta inválida: ${opts.port}`));
+        process.exit(1);
+    }
+    const allowedOrigins = (process.env.PARIS_SERVE_ORIGINS?.split(',').map((s) => s.trim()).filter(Boolean)) ?? DEFAULT_ALLOWED_ORIGINS;
+    let handle;
+    try {
+        handle = await startServeServer({ port: portNum, allowedOrigins, token });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(c.red(`Falha ao iniciar paris serve: ${msg}`));
+        process.exit(1);
+    }
+    console.log();
+    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(', ')}`);
+    console.log(`  ${c.dim('Ctrl+C pra encerrar.')}`);
+    console.log();
+    const shutdown = () => {
+        handle.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,25 @@
+import { apiAuthFetch } from '../lib/api.js';
+import { c } from '../lib/colors.js';
+export async function statusCommand() {
+    const [workspace, current] = await Promise.all([
+        apiAuthFetch('/immersion-app/v1/workspace'),
+        apiAuthFetch('/immersion-app/v1/missions/current'),
+    ]);
+    console.log();
+    console.log(c.bold(`${workspace.immersion.name} (${workspace.immersion.slug})`));
+    console.log(`  ${c.dim('status')}: ${workspace.status === 'active' ? c.green('active') : c.yellow('graduated')}`);
+    console.log(`  ${c.dim('fase')}:   ${workspace.phase} · dia ${workspace.day_number}`);
+    console.log(`  ${c.dim('janela')}: ${workspace.immersion.starts_at.slice(0, 10)} → ${workspace.immersion.ends_at.slice(0, 10)}`);
+    if (workspace.graduated_at) {
+        console.log(`  ${c.dim('graduado em')}: ${workspace.graduated_at.slice(0, 10)}`);
+    }
+    console.log();
+    if (current.current) {
+        console.log(c.bold('Tarefa em foco:'));
+        console.log(`  ${c.cyan(current.current.title)} ${c.dim('(' + current.current.deliverable_type + ', ' + current.current.status + ')')}`);
+        console.log(`  ${c.dim(current.current.id)}`);
+    }
+    else {
+        console.log(c.dim('Sem tarefa em foco.'));
+    }
+}

package/dist/commands/tasks.d.ts

@@ -0,0 +1 @@
+export declare function tasksCommand(): Promise<void>;