paris-immersion 0.1.6 → 0.1.8

package/dist/commands/daemon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `paris daemon <install|uninstall|status>` — gerencia o serviço persistente
+ * do `paris serve` (o agente que o terminal embutido do curso espelha). O
+ * instalador chama `install`; o `paris logout` chama `uninstall`.
+ */
+export declare function daemonCommand(action: string): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,35 @@
+import { installDaemon, uninstallDaemon, daemonStatus } from '../lib/daemon.js';
+import { c } from '../lib/colors.js';
+/**
+ * `paris daemon <install|uninstall|status>` — gerencia o serviço persistente
+ * do `paris serve` (o agente que o terminal embutido do curso espelha). O
+ * instalador chama `install`; o `paris logout` chama `uninstall`.
+ */
+export async function daemonCommand(action) {
+    const act = (action || '').toLowerCase();
+    if (act === 'install') {
+        try {
+            const { mechanism } = await installDaemon();
+            console.log(c.green(`✓ paris serve instalado como serviço (${mechanism}).`));
+            console.log(c.dim('  Sobe sozinho no login e reinicia se cair — o terminal do curso conecta sempre.'));
+        }
+        catch (err) {
+            console.log(c.yellow(`! Não consegui instalar o serviço: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(c.dim('  Você ainda pode rodar `paris serve` num terminal manualmente.'));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (act === 'uninstall') {
+        await uninstallDaemon();
+        console.log(c.green('✓ Serviço do paris serve removido.'));
+        return;
+    }
+    if (act === 'status') {
+        const on = await daemonStatus();
+        console.log(on ? c.green('● paris serve: serviço ativo') : c.dim('○ paris serve: serviço não instalado'));
+        return;
+    }
+    console.log(c.yellow("Uso: paris daemon <install|uninstall|status>"));
+    process.exitCode = 1;
+}

package/dist/commands/logout.js

@@ -1,8 +1,12 @@
 import { apiAuthFetch } from '../lib/api.js';
 import { deleteCredentials, readCredentials } from '../lib/credentials.js';
+import { uninstallDaemon } from '../lib/daemon.js';
 import { c } from '../lib/colors.js';
 export async function logoutCommand() {
     const creds = await readCredentials();
+    // Remove o serviço persistente do paris serve (best-effort) — não faz sentido
+    // o agente seguir subindo no login depois que o aluno saiu.
+    await uninstallDaemon();
     if (!creds) {
         console.log(c.dim('Nenhuma sessão local pra encerrar.'));
         return;

package/dist/index.js

@@ -9,10 +9,11 @@ import { reopenCommand } from './commands/reopen.js';
 import { graduateCommand } from './commands/graduate.js';
 import { logoutCommand } from './commands/logout.js';
 import { serveCommand } from './commands/serve.js';
+import { daemonCommand } from './commands/daemon.js';
 const program = new Command()
     .name('paris')
     .description('Paris Immersion — CLI do aluno (login, workspace, tarefas)')
-    .version('0.1.6');
+    .version('0.1.8');
 program
     .command('login')
     .description('Autenticar com sua conta Paris (device-code OR --token direto)')
@@ -56,6 +57,10 @@ program
     .description('Sobe WS local (ws://localhost:31000) para o terminal embarcado do onboarding')
     .option('--port <port>', 'Porta do WebSocket', '31000')
     .action(serveCommand);
+program
+    .command('daemon <action>')
+    .description('Serviço persistente do paris serve (install | uninstall | status)')
+    .action(daemonCommand);
 program.parseAsync().catch((err) => {
     console.error('\n[paris] erro:', err?.message ?? err);
     process.exit(1);

package/dist/lib/daemon.d.ts

@@ -0,0 +1,6 @@
+export declare function installDaemon(): Promise<{
+    mechanism: string;
+}>;
+/** Best-effort — nunca lança (usado no logout, não pode travar). */
+export declare function uninstallDaemon(): Promise<void>;
+export declare function daemonStatus(): Promise<boolean>;

package/dist/lib/daemon.js

@@ -0,0 +1,246 @@
+/**
+ * paris-serve como serviço persistente — pra que o terminal embutido do
+ * onboarding SEMPRE tenha um agente pareável, sem o aluno rodar nada e sem
+ * engasgo após reboot/crash. Leve: o serve só mantém uma conexão wss com o
+ * relay; o Claude só é spawnado quando um viewer (a página do curso) conecta.
+ *
+ * - macOS  → LaunchAgent (~/Library/LaunchAgents) com RunAtLoad + KeepAlive.
+ * - Windows→ Scheduled Task AtLogOn (oculta, via .vbs) com restart-on-failure.
+ * - Linux  → systemd --user service (Restart=always); senão erro amigável.
+ *
+ * Removido por `paris logout` (uninstallDaemon) ou `paris daemon uninstall`.
+ */
+import { promises as fs } from 'node:fs';
+import fsSync from 'node:fs';
+import { homedir, platform } from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readCredentials } from './credentials.js';
+const execFileAsync = promisify(execFile);
+const LABEL = 'ai.parisgroup.serve';
+const WIN_TASK = 'ParisServe';
+function parisDir() {
+    return path.join(homedir(), '.paris');
+}
+function serveLog() {
+    return path.join(parisDir(), 'serve.log');
+}
+/** Caminhos absolutos que o launchd/Task precisam pra rodar `paris serve`. */
+function resolveRun() {
+    const node = process.execPath;
+    let entry = process.argv[1] || '';
+    try {
+        entry = fsSync.realpathSync(entry);
+    }
+    catch {
+        /* mantém argv[1] */
+    }
+    return { node, entry };
+}
+async function resolveApiUrl() {
+    if (process.env.PARIS_API_URL)
+        return process.env.PARIS_API_URL;
+    const creds = await readCredentials();
+    return creds?.api_url ?? undefined;
+}
+function escapeXml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+// ─── macOS (launchd) ──────────────────────────────────────────────────────
+function plistPath() {
+    return path.join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+}
+function buildPlist(node, entry, apiUrl, pathEnv) {
+    const env = [
+        apiUrl ? `    <key>PARIS_API_URL</key><string>${escapeXml(apiUrl)}</string>` : '',
+        `    <key>PATH</key><string>${escapeXml(pathEnv)}</string>`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(node)}</string>
+    <string>${escapeXml(entry)}</string>
+    <string>serve</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${env}
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ThrottleInterval</key><integer>10</integer>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${escapeXml(serveLog())}</string>
+  <key>StandardErrorPath</key><string>${escapeXml(serveLog())}</string>
+</dict>
+</plist>
+`;
+}
+function guiDomain() {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
+    return `gui/${uid}`;
+}
+async function installDarwin() {
+    const { node, entry } = resolveRun();
+    const apiUrl = await resolveApiUrl();
+    const pathEnv = process.env.PATH || '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin';
+    await fs.mkdir(parisDir(), { recursive: true, mode: 0o700 });
+    await fs.mkdir(path.dirname(plistPath()), { recursive: true });
+    const p = plistPath();
+    await fs.writeFile(p, buildPlist(node, entry, apiUrl, pathEnv));
+    const domain = guiDomain();
+    await execFileAsync('launchctl', ['bootout', `${domain}/${LABEL}`]).catch(() => { });
+    try {
+        await execFileAsync('launchctl', ['bootstrap', domain, p]);
+    }
+    catch {
+        // launchctl mais antigo / edge — caminho clássico.
+        await execFileAsync('launchctl', ['unload', p]).catch(() => { });
+        await execFileAsync('launchctl', ['load', '-w', p]);
+    }
+    await execFileAsync('launchctl', ['kickstart', '-k', `${domain}/${LABEL}`]).catch(() => { });
+}
+async function uninstallDarwin() {
+    const p = plistPath();
+    await execFileAsync('launchctl', ['bootout', `${guiDomain()}/${LABEL}`]).catch(() => { });
+    await execFileAsync('launchctl', ['unload', p]).catch(() => { });
+    await fs.rm(p, { force: true }).catch(() => { });
+}
+async function statusDarwin() {
+    try {
+        const { stdout } = await execFileAsync('launchctl', ['list']);
+        return stdout.includes(LABEL);
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Windows (Scheduled Task, oculto via .vbs) ──────────────────────────────
+async function installWin32() {
+    const { node, entry } = resolveRun();
+    const apiUrl = await resolveApiUrl();
+    await fs.mkdir(parisDir(), { recursive: true });
+    const log = serveLog();
+    const cmdPath = path.join(parisDir(), 'serve-daemon.cmd');
+    const vbsPath = path.join(parisDir(), 'serve-daemon.vbs');
+    const cmd = `@echo off\r\n` +
+        (apiUrl ? `set "PARIS_API_URL=${apiUrl}"\r\n` : '') +
+        `"${node}" "${entry}" serve >> "${log}" 2>&1\r\n`;
+    await fs.writeFile(cmdPath, cmd);
+    // .vbs roda o .cmd com janela 0 (oculta) — evita o flash do console no logon.
+    await fs.writeFile(vbsPath, `CreateObject("Wscript.Shell").Run "cmd /c ""${cmdPath}""", 0, False\r\n`);
+    const ps = [
+        `$a = New-ScheduledTaskAction -Execute 'wscript.exe' -Argument '"${vbsPath}"'`,
+        `$t = New-ScheduledTaskTrigger -AtLogOn`,
+        `$s = New-ScheduledTaskSettingsSet -Hidden -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1)`,
+        `Register-ScheduledTask -TaskName '${WIN_TASK}' -Action $a -Trigger $t -Settings $s -Force | Out-Null`,
+        `Start-ScheduledTask -TaskName '${WIN_TASK}'`,
+    ].join('; ');
+    await execFileAsync('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', ps]);
+}
+async function uninstallWin32() {
+    await execFileAsync('powershell', [
+        '-NoProfile',
+        '-Command',
+        `Unregister-ScheduledTask -TaskName '${WIN_TASK}' -Confirm:$false`,
+    ]).catch(() => { });
+}
+async function statusWin32() {
+    try {
+        await execFileAsync('schtasks', ['/Query', '/TN', WIN_TASK]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Linux (systemd --user) ────────────────────────────────────────────────
+function unitPath() {
+    return path.join(homedir(), '.config', 'systemd', 'user', 'paris-serve.service');
+}
+async function installLinux() {
+    const { node, entry } = resolveRun();
+    const apiUrl = await resolveApiUrl();
+    await fs.mkdir(path.dirname(unitPath()), { recursive: true });
+    const unit = `[Unit]
+Description=Paris Immersion serve (agente do terminal embutido)
+After=network-online.target
+
+[Service]
+ExecStart=${node} ${entry} serve
+Restart=always
+RestartSec=5
+${apiUrl ? `Environment=PARIS_API_URL=${apiUrl}\n` : ''}Environment=PATH=${process.env.PATH || '/usr/local/bin:/usr/bin:/bin'}
+
+[Install]
+WantedBy=default.target
+`;
+    await fs.writeFile(unitPath(), unit);
+    await execFileAsync('systemctl', ['--user', 'daemon-reload']).catch(() => { });
+    await execFileAsync('systemctl', ['--user', 'enable', '--now', 'paris-serve.service']);
+}
+async function uninstallLinux() {
+    await execFileAsync('systemctl', ['--user', 'disable', '--now', 'paris-serve.service']).catch(() => { });
+    await fs.rm(unitPath(), { force: true }).catch(() => { });
+    await execFileAsync('systemctl', ['--user', 'daemon-reload']).catch(() => { });
+}
+async function statusLinux() {
+    try {
+        const { stdout } = await execFileAsync('systemctl', ['--user', 'is-active', 'paris-serve.service']);
+        return stdout.trim() === 'active';
+    }
+    catch {
+        return false;
+    }
+}
+// ─── API pública ────────────────────────────────────────────────────────────
+export async function installDaemon() {
+    switch (platform()) {
+        case 'darwin':
+            await installDarwin();
+            return { mechanism: 'launchd LaunchAgent (RunAtLoad + KeepAlive)' };
+        case 'win32':
+            await installWin32();
+            return { mechanism: 'Scheduled Task AtLogOn (oculta, restart-on-failure)' };
+        case 'linux':
+            await installLinux();
+            return { mechanism: 'systemd --user (Restart=always)' };
+        default:
+            throw new Error(`plataforma não suportada para daemon: ${platform()}`);
+    }
+}
+/** Best-effort — nunca lança (usado no logout, não pode travar). */
+export async function uninstallDaemon() {
+    try {
+        switch (platform()) {
+            case 'darwin':
+                return await uninstallDarwin();
+            case 'win32':
+                return await uninstallWin32();
+            case 'linux':
+                return await uninstallLinux();
+        }
+    }
+    catch {
+        /* best-effort */
+    }
+}
+export async function daemonStatus() {
+    switch (platform()) {
+        case 'darwin':
+            return statusDarwin();
+        case 'win32':
+            return statusWin32();
+        case 'linux':
+            return statusLinux();
+        default:
+            return false;
+    }
+}

package/dist/lib/relay-agent.js

@@ -12,6 +12,7 @@ import { WebSocket } from 'ws';
 import { spawnCoachPty } from '../commands/serve.js';
 const TYPE_DATA = 0x00;
 const TYPE_RESIZE = 0x01;
+const TYPE_WORKSPACE = 0x02; // agent → viewer: caminho do workspace (pro handoff nativo)
 /** plaintext = type(1) || body → frame = nonce(12) || AES-256-GCM(enc||tag). */
 function seal(key, type, body) {
     const nonce = crypto.randomBytes(12);
@@ -183,6 +184,16 @@ export async function startRelayAgent(opts) {
                             killTimer = undefined;
                         }
                         startPty(); // no-op se já tem Claude vivo → reatacha na mesma sessão
+                        // Informa o caminho do workspace pro browser oferecer o handoff nativo
+                        // ("seguir no terminal nativo" → cd <ws> && claude --continue).
+                        if (opts.cwd && ws && ws.readyState === WebSocket.OPEN) {
+                            try {
+                                ws.send(seal(key, TYPE_WORKSPACE, Buffer.from(opts.cwd, 'utf8')), { binary: true });
+                            }
+                            catch {
+                                /* noop */
+                            }
+                        }
                     }
                     else if (m.t === 'viewer-left') {
                         // Não mata na hora — janela de graça pra reconexão reatachar.

package/package.json

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