paris-immersion 0.1.29 → 0.1.30

package/dist/commands/serve.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { readCredentials } from '../lib/credentials.js';
 import { ensureWorkspace } from './install.js';
 import { startRelayAgent } from '../lib/relay-agent.js';
+import { parseMissionAction, startMissionInOrca } from '../lib/orca-launcher.js';
 import { renderTostudyCommand } from '../templates/tostudy-command.js';
 import { renderHookScript } from '../templates/hook.js';
 import { renderSettingsJson } from '../templates/settings.js';
@@ -332,7 +333,7 @@ export async function startServeServer(opts) {
         wss.once('listening', () => resolve());
         wss.once('error', reject);
     });
-    wss.on('connection', (ws) => {
+    wss.on('connection', (ws, req) => {
         // TCP_NODELAY: sem Nagle no socket local (caminho dev ws://localhost).
         try {
             ws._socket?.setNoDelay?.(true);
@@ -343,6 +344,33 @@ export async function startServeServer(opts) {
             ws.send('READY\n');
             return;
         }
+        // Modo AÇÃO (?mode=action): conexão one-shot da War Room ("Iniciar missão"
+        // abre o Orca) — sem pty. Espera um único 'ACTION:<json>', responde
+        // 'ACTIONRESULT:<json>' e fecha. Espelho local do TYPE_ACTION do relay.
+        const connUrl = new URL(req?.url ?? '/', 'http://localhost');
+        if (connUrl.searchParams.get('mode') === 'action') {
+            ws.on('message', (m) => {
+                const s = m.toString();
+                if (!s.startsWith('ACTION:'))
+                    return;
+                const action = parseMissionAction(s.slice('ACTION:'.length));
+                if (!action) {
+                    ws.send('ACTIONRESULT:' + JSON.stringify({ ok: false, error: 'Ação inválida.' }));
+                    ws.close(1000);
+                    return;
+                }
+                void startMissionInOrca({ cwd: opts.cwd ?? process.cwd(), prompt: action.prompt, title: action.title }).then((result) => {
+                    try {
+                        ws.send('ACTIONRESULT:' + JSON.stringify(result));
+                        ws.close(1000);
+                    }
+                    catch {
+                        /* viewer já foi */
+                    }
+                });
+            });
+            return;
+        }
         let p;
         try {
             // Lazy require inside spawnCoachPty — keeps `paris serve --help` working

package/dist/lib/orca-launcher.d.ts

@@ -0,0 +1,16 @@
+export interface StartMissionResult {
+    ok: boolean;
+    error?: string;
+}
+export declare function startMissionInOrca(opts: {
+    cwd: string;
+    prompt: string;
+    title?: string;
+}): Promise<StartMissionResult>;
+/** Payload da ação vinda do browser (War Room). */
+export interface MissionAction {
+    action: 'start_mission';
+    prompt: string;
+    title?: string;
+}
+export declare function parseMissionAction(raw: string): MissionAction | null;

package/dist/lib/orca-launcher.js

@@ -0,0 +1,90 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileP = promisify(execFile);
+/**
+ * "Iniciar missão" (2026-08-14): abre o Orca na máquina do aluno, já na pasta
+ * do workspace da imersão, com um terminal rodando `claude` com o prompt
+ * inicial da missão. Chamado pelo serve/relay-agent quando a War Room manda a
+ * ação `start_mission`.
+ *
+ * Usa a CLI do Orca (instalada pelo kit do onboarding em ~/.local/bin/orca):
+ *   orca open                 → garante app + runtime de pé
+ *   orca repo add <ws>        → registra o workspace (idempotente; falha ignorada)
+ *   orca terminal create ...  → aba nova com o claude + prompt, em foco
+ */
+function findOrcaBin() {
+    const candidates = [
+        path.join(homedir(), '.local', 'bin', 'orca'),
+        '/usr/local/bin/orca',
+        '/opt/homebrew/bin/orca',
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+export async function startMissionInOrca(opts) {
+    const orca = findOrcaBin();
+    if (!orca) {
+        return {
+            ok: false,
+            error: 'Orca não encontrado nesta máquina. Rode o instalador da imersão de novo, ou abra o Orca manualmente na pasta da imersão.',
+        };
+    }
+    if (!opts.cwd || !existsSync(opts.cwd)) {
+        return { ok: false, error: 'Workspace da imersão não encontrado nesta máquina.' };
+    }
+    try {
+        // 1. App + runtime de pé (no-op se já rodando). `orca open` espera o runtime
+        //    ficar alcançável — timeout generoso pro cold start do app.
+        await execFileP(orca, ['open'], { timeout: 45_000 });
+        // 2. Workspace registrado (idempotente na prática: "já existe" é sucesso).
+        await execFileP(orca, ['repo', 'add', opts.cwd, '--json'], { timeout: 15_000 }).catch(() => { });
+        // 3. Aba de terminal com o Claude já na missão, em foco. Aspas simples no
+        //    prompt são escapadas pro shell da aba.
+        const promptQ = opts.prompt.replace(/'/g, `'\\''`);
+        const command = `claude --dangerously-skip-permissions '${promptQ}'`;
+        const args = [
+            'terminal',
+            'create',
+            '--worktree',
+            `path:${opts.cwd}`,
+            '--command',
+            command,
+            '--focus',
+            '--json',
+        ];
+        if (opts.title)
+            args.push('--title', opts.title.slice(0, 60));
+        await execFileP(orca, args, { timeout: 30_000 });
+        return { ok: true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            error: `Não consegui abrir a missão no Orca: ${msg.slice(0, 200)}`,
+        };
+    }
+}
+export function parseMissionAction(raw) {
+    try {
+        const j = JSON.parse(raw);
+        if (j.action !== 'start_mission')
+            return null;
+        if (typeof j.prompt !== 'string' || j.prompt.length === 0 || j.prompt.length > 4000)
+            return null;
+        return {
+            action: 'start_mission',
+            prompt: j.prompt,
+            title: typeof j.title === 'string' ? j.title : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/relay-agent.js

@@ -10,9 +10,12 @@
 import crypto from 'node:crypto';
 import { WebSocket } from 'ws';
 import { spawnCoachPty } from '../commands/serve.js';
+import { parseMissionAction, startMissionInOrca } from './orca-launcher.js';
 const TYPE_DATA = 0x00;
 const TYPE_RESIZE = 0x01;
 const TYPE_WORKSPACE = 0x02; // agent → viewer: caminho do workspace (pro handoff nativo)
+const TYPE_ACTION = 0x03; // viewer → agent: ação one-shot JSON (ex.: start_mission → abre o Orca)
+const TYPE_ACTION_RESULT = 0x04; // agent → viewer: resultado JSON da ação
 /** plaintext = type(1) || body → frame = nonce(12) || AES-256-GCM(enc||tag). */
 function seal(key, type, body) {
     const nonce = crypto.randomBytes(12);
@@ -297,6 +300,11 @@ export async function startRelayAgent(opts) {
                 try {
                     const m = JSON.parse(data.toString());
                     if (m.t === 'viewer-joined') {
+                        // Viewer de AÇÃO ("Iniciar missão" da War Room): não é o terminal do
+                        // curso — NÃO spawna o pty; a ação chega num frame TYPE_ACTION logo
+                        // em seguida e é respondida com TYPE_ACTION_RESULT.
+                        if (m.mode === 'action')
+                            return;
                         if (killTimer) {
                             clearTimeout(killTimer);
                             killTimer = undefined;
@@ -328,9 +336,32 @@ export async function startRelayAgent(opts) {
                 }
                 return;
             }
-            // Frame E2E do viewer (stdin/resize) — decifra e aplica no pty.
+            // Frame E2E do viewer (stdin/resize/ação) — decifra e aplica.
             const msg = open(key, data);
-            if (!msg || !pty)
+            if (!msg)
+                return;
+            if (msg.type === TYPE_ACTION) {
+                // Ação one-shot independente do pty (o viewer de ação nem o spawna).
+                const action = parseMissionAction(msg.body.toString('utf8'));
+                const respond = (result) => {
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        try {
+                            ws.send(seal(key, TYPE_ACTION_RESULT, Buffer.from(JSON.stringify(result), 'utf8')), { binary: true });
+                        }
+                        catch {
+                            /* viewer já foi */
+                        }
+                    }
+                };
+                if (!action) {
+                    respond({ ok: false, error: 'Ação inválida.' });
+                    return;
+                }
+                log(`relay: ação start_mission (${action.title ?? 'sem título'})`);
+                void startMissionInOrca({ cwd: opts.cwd, prompt: action.prompt, title: action.title }).then(respond);
+                return;
+            }
+            if (!pty)
                 return;
             if (msg.type === TYPE_DATA) {
                 pty.write(msg.body.toString('utf8'));

package/package.json

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