paris-immersion 0.1.7 → 0.1.9

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/commands/serve.d.ts

@@ -38,9 +38,19 @@ export interface ServeHandle {
     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.
+ * Descobre o slash-command do tutor pra injetar no kickoff. O `@tostudy-ai/cli`
+ * instala o comando com nome ESPECÍFICO do curso (`.claude/commands/tostudy-<slug>.md`),
+ * NÃO `/tostudy` — então cravar `/tostudy` dava "Unknown command: /tostudy" e o
+ * curso não iniciava. Aqui varremos `.claude/commands/tostudy*.md` e usamos o
+ * comando real; com vários cursos, casamos com o `slug` ativo do
+ * `.tostudy/workspace.json`. Override explícito via PARIS_COACH_KICKOFF.
+ * Fallback `/tostudy` (legado / antes do `tostudy` instalar o comando).
+ */
+export declare function resolveKickoff(cwd: string): string;
+/**
+ * Spawn the coached pty (`claude '/tostudy-<curso>'` 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;
 /**

package/dist/commands/serve.js

@@ -1,6 +1,6 @@
 import { WebSocketServer } from 'ws';
 import { createRequire } from 'node:module';
-import { promises as fs, chmodSync, existsSync, statSync } from 'node:fs';
+import { promises as fs, chmodSync, existsSync, statSync, readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { readCredentials } from '../lib/credentials.js';
 import { ensureWorkspace } from './install.js';
@@ -69,20 +69,60 @@ const DEFAULT_ALLOWED_ORIGINS = [
 // `/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.
+ * Descobre o slash-command do tutor pra injetar no kickoff. O `@tostudy-ai/cli`
+ * instala o comando com nome ESPECÍFICO do curso (`.claude/commands/tostudy-<slug>.md`),
+ * NÃO `/tostudy` — então cravar `/tostudy` dava "Unknown command: /tostudy" e o
+ * curso não iniciava. Aqui varremos `.claude/commands/tostudy*.md` e usamos o
+ * comando real; com vários cursos, casamos com o `slug` ativo do
+ * `.tostudy/workspace.json`. Override explícito via PARIS_COACH_KICKOFF.
+ * Fallback `/tostudy` (legado / antes do `tostudy` instalar o comando).
+ */
+export function resolveKickoff(cwd) {
+    const override = process.env.PARIS_COACH_KICKOFF;
+    if (override)
+        return override;
+    try {
+        const cmdDir = path.join(cwd, '.claude', 'commands');
+        const files = readdirSync(cmdDir).filter((f) => /^tostudy.*\.md$/i.test(f));
+        if (files.length === 0)
+            return '/tostudy';
+        let chosen = files.sort()[0];
+        if (files.length > 1) {
+            try {
+                const ws = JSON.parse(readFileSync(path.join(cwd, '.tostudy', 'workspace.json'), 'utf8'));
+                const slug = ws.slug?.toLowerCase();
+                if (slug) {
+                    const match = files.find((f) => f.toLowerCase() === `tostudy-${slug}.md`) ??
+                        files.find((f) => f.toLowerCase().includes(slug));
+                    if (match)
+                        chosen = match;
+                }
+            }
+            catch {
+                /* sem workspace.json legível — usa o primeiro */
+            }
+        }
+        return '/' + chosen.replace(/\.md$/i, '');
+    }
+    catch {
+        return '/tostudy';
+    }
+}
+/**
+ * Spawn the coached pty (`claude '/tostudy-<curso>'` 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 kickoff = resolveKickoff(cwd);
     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, `'\\''`)}'`];
+        ? ['-NoLogo', '-Command', `claude "${kickoff.replace(/"/g, '`"')}"`]
+        : ['-l', '-c', `claude '${kickoff.replace(/'/g, `'\\''`)}'`];
     return ptyMod.spawn(shell, shellArgs, {
         name: 'xterm-color',
         cols: 80,

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.7');
+    .version('0.1.9');
 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/package.json

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