rms-devremote 3.0.0

package/dist/commands/link.js

@@ -0,0 +1,112 @@
+import { fork } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { isSetupDone, readConfig, BATTERY_PID_PATH } from '../services/config.js';
+import { isServerRunning, checkPortAvailable, startServer } from '../services/ttyd.js';
+import { sessionExists, createSession, attachSession } from '../services/tmux.js';
+import { isDockerRunning, isComposeUp, composeUp } from '../services/docker.js';
+import { mergeHooks } from '../services/hooks.js';
+import { inhibitSleep, getBatteryInfo } from '../services/battery.js';
+import { writePid } from '../services/process.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function link() {
+    // 1. Guard: setup must be done
+    if (!isSetupDone()) {
+        console.error(chalk.red('✖ rms-devremote n\'est pas encore configure. Lance: rms-devremote setup'));
+        process.exit(1);
+    }
+    const config = readConfig();
+    // 2. Guard: already linked
+    if (isServerRunning()) {
+        console.log(chalk.yellow('⚠  Session déjà linkée.'));
+        console.log(chalk.white('   URL: ') + chalk.blue(config.domains.terminal));
+        console.log(chalk.gray('   → rms-devremote unlink  pour stopper'));
+        console.log(chalk.gray('   → rms-devremote attach  pour rejoindre'));
+        return;
+    }
+    // 3. Check Docker
+    if (!isDockerRunning()) {
+        console.error(chalk.red('✖ Docker n\'est pas en cours d\'exécution. Démarre Docker et réessaie.'));
+        process.exit(1);
+    }
+    if (!isComposeUp()) {
+        console.log(chalk.cyan('  Démarrage du stack Docker Compose…'));
+        try {
+            composeUp();
+            console.log(chalk.green('✔ Docker Compose démarré.'));
+        }
+        catch (err) {
+            console.error(chalk.red('✖ Échec du démarrage Docker Compose.'), err);
+            process.exit(1);
+        }
+    }
+    // 4. Check/create tmux session
+    if (!sessionExists()) {
+        console.log(chalk.cyan('  Création de la session tmux…'));
+        createSession();
+        console.log(chalk.green('✔ Session tmux créée.'));
+    }
+    else {
+        console.log(chalk.green('✔ Session tmux existante.'));
+    }
+    // 5. Check port availability
+    const portCheck = checkPortAvailable();
+    if (!portCheck.available) {
+        console.error(chalk.red(`✖ Le port ${config.ttyd.port} est bloqué par le processus PID ${portCheck.blockingPid ?? 'inconnu'}.`));
+        console.error(chalk.gray(`  Arrête ce processus ou change le port dans la config.`));
+        process.exit(1);
+    }
+    // 6. Start devremote terminal server
+    console.log(chalk.cyan('  Démarrage du serveur terminal…'));
+    let serverPid;
+    try {
+        serverPid = startServer();
+        console.log(chalk.green(`✔ Serveur terminal démarré (PID ${serverPid}).`));
+    }
+    catch (err) {
+        console.error(chalk.red('✖ Impossible de démarrer le serveur terminal.'), err);
+        process.exit(1);
+    }
+    // 7. Merge hooks
+    try {
+        mergeHooks();
+        console.log(chalk.green('✔ Hooks Claude configurés.'));
+    }
+    catch {
+        console.log(chalk.yellow('⚠  Impossible de configurer les hooks Claude.'));
+    }
+    // 8. Inhibit sleep
+    try {
+        inhibitSleep();
+        console.log(chalk.green('✔ Mise en veille désactivée.'));
+    }
+    catch {
+        console.log(chalk.yellow('⚠  Impossible de désactiver la mise en veille.'));
+    }
+    // 9. Battery warning
+    const battery = getBatteryInfo();
+    if (battery.present && !battery.charging) {
+        console.log(chalk.yellow(`⚠  Batterie non branchée — ${battery.percent}% restant. Pense à brancher le chargeur.`));
+    }
+    // 10. Fork battery worker if battery present
+    if (battery.present) {
+        const workerPath = resolve(__dirname, '..', 'services', 'battery-worker.js');
+        const worker = fork(workerPath, [], { detached: true, stdio: 'ignore' });
+        if (worker.pid !== undefined) {
+            writePid(BATTERY_PID_PATH, worker.pid);
+        }
+        worker.unref();
+        console.log(chalk.green('✔ Surveillance batterie démarrée.'));
+    }
+    // 11. Success
+    console.log();
+    console.log(chalk.bold.green('✔ Terminal linked!'));
+    console.log(chalk.white('  URL: ') + chalk.blue(config.domains.terminal));
+    console.log();
+    // 12. Attach tmux session (blocks until detach/exit)
+    // tmux + server continue in background if terminal is closed
+    attachSession();
+}
+export default link;

package/dist/commands/ping.d.ts

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

package/dist/commands/ping.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import { isSetupDone } from '../services/config.js';
+import { sendNotification } from '../services/ntfy.js';
+export async function ping() {
+    if (!isSetupDone()) {
+        console.log(chalk.yellow('⚠  rms-devremote n\'est pas encore configuré. Lance: rms-devremote setup'));
+        return;
+    }
+    console.log(chalk.cyan('  Envoi d\'une notification de test…'));
+    const ok = await sendNotification('rms-devremote ping — connexion OK ✓', 'default');
+    if (ok) {
+        console.log(chalk.green('✔ Notification envoyée avec succès.'));
+        console.log(chalk.gray('  Vérifie ton appareil pour la notification ntfy.'));
+    }
+    else {
+        console.log(chalk.red('✖ Échec de l\'envoi de la notification.'));
+        console.log(chalk.gray('  Assure-toi que le conteneur ntfy est en cours d\'exécution.'));
+        console.log(chalk.gray('  Lance: rms-devremote status'));
+    }
+}
+export default ping;

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { isSetupDone } from '../services/config.js';
+import { startSetupServer, getSetupUrl } from '../setup-server/server.js';
+import { run } from '../services/shell.js';
+export async function setup() {
+    // Guard: already configured
+    if (isSetupDone()) {
+        console.log(chalk.yellow('Deja configure. Pour reconfigurer, supprime ~/.rms-devremote/ et relance.'));
+        return;
+    }
+    // Start the setup HTTP + WebSocket server
+    const { close } = await startSetupServer();
+    const url = getSetupUrl();
+    // Open browser (ignore errors — may not have a display)
+    try {
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            run('open', [url]);
+        }
+        else {
+            run('xdg-open', [url]);
+        }
+    }
+    catch {
+        // Silently ignore — user can open manually
+    }
+    console.log();
+    console.log(chalk.bold.cyan('Setup en cours sur ' + url + '...'));
+    console.log(chalk.gray('Ouvrez l\'URL ci-dessus dans votre navigateur si elle ne s\'est pas ouverte automatiquement.'));
+    console.log(chalk.gray('Ctrl+C pour annuler'));
+    console.log();
+    // Poll until setup is done (config.json + .env written)
+    await new Promise((resolve) => {
+        const interval = setInterval(() => {
+            if (isSetupDone()) {
+                clearInterval(interval);
+                resolve();
+            }
+        }, 1000);
+        // Allow Ctrl+C to cancel cleanly
+        process.once('SIGINT', () => {
+            clearInterval(interval);
+            close();
+            console.log(chalk.gray('\nSetup annule.'));
+            process.exit(0);
+        });
+    });
+    // Teardown server
+    close();
+    console.log();
+    console.log(chalk.bold.green('Setup termine ! Lance: rms-devremote link'));
+    console.log();
+}
+export default setup;

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import { isSetupDone, readConfig } from '../services/config.js';
+import { getContainerStatus } from '../services/docker.js';
+import { healthCheck } from '../services/ntfy.js';
+import { isTtydRunning } from '../services/ttyd.js';
+import { sessionExists } from '../services/tmux.js';
+import { hasDevremoteHooks } from '../services/hooks.js';
+import { getBatteryInfo } from '../services/battery.js';
+function statusIcon(ok) {
+    return ok ? chalk.green('●') : chalk.red('●');
+}
+function statusLabel(ok, onLabel, offLabel) {
+    return ok ? chalk.green(onLabel) : chalk.red(offLabel);
+}
+export async function status() {
+    if (!isSetupDone()) {
+        console.log(chalk.yellow('⚠  rms-devremote n\'est pas encore configuré. Lance: rms-devremote setup'));
+        return;
+    }
+    const config = readConfig();
+    // Gather status info
+    const tunnelStatus = getContainerStatus('devremote-tunnel');
+    const ntfyStatus = getContainerStatus('devremote-ntfy');
+    const ntfyHealth = await healthCheck();
+    const ttydRunning = isTtydRunning();
+    const tmuxSession = sessionExists();
+    const hooksConfigured = hasDevremoteHooks();
+    const battery = getBatteryInfo();
+    console.log();
+    console.log(chalk.bold.cyan('rms-devremote — Status'));
+    console.log(chalk.cyan('─────────────────────────────────────────'));
+    // Docker services
+    console.log(chalk.bold.white('Docker:'));
+    const tunnelOk = tunnelStatus === 'running';
+    const ntfyOk = ntfyStatus === 'running';
+    console.log(`  ${statusIcon(tunnelOk)} Tunnel (Cloudflare)  ${statusLabel(tunnelOk, 'running', tunnelStatus)}`);
+    console.log(`  ${statusIcon(ntfyOk)} ntfy                ${statusLabel(ntfyOk, 'running', ntfyStatus)}`);
+    console.log(`  ${statusIcon(ntfyHealth)} ntfy health          ${statusLabel(ntfyHealth, 'healthy', 'unreachable')}`);
+    console.log();
+    console.log(chalk.bold.white('Services:'));
+    console.log(`  ${statusIcon(ttydRunning)} terminal server      ${statusLabel(ttydRunning, 'running', 'stopped')}`);
+    console.log(`  ${statusIcon(tmuxSession)} tmux session         ${statusLabel(tmuxSession, 'active', 'no session')}`);
+    console.log(`  ${statusIcon(hooksConfigured)} Claude hooks         ${statusLabel(hooksConfigured, 'configured', 'not configured')}`);
+    console.log();
+    console.log(chalk.bold.white('Battery:'));
+    if (battery.present) {
+        const chargingIcon = battery.charging ? chalk.green('⚡ charging') : chalk.yellow('🔋 discharging');
+        const percentColor = battery.percent > 50
+            ? chalk.green(`${battery.percent}%`)
+            : battery.percent > 20
+                ? chalk.yellow(`${battery.percent}%`)
+                : chalk.red(`${battery.percent}%`);
+        console.log(`  ${percentColor}  ${chargingIcon}`);
+    }
+    else {
+        console.log(`  ${chalk.gray('No battery detected (desktop or AC only)')}`);
+    }
+    console.log();
+    console.log(chalk.bold.white('Domains:'));
+    console.log(`  Terminal : ${chalk.blue(config.domains.terminal)}`);
+    console.log(`  Notify   : ${chalk.blue(config.domains.notify)}`);
+    console.log(chalk.cyan('─────────────────────────────────────────'));
+    console.log();
+}
+export default status;

package/dist/commands/unlink.d.ts

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

package/dist/commands/unlink.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { BATTERY_PID_PATH, INHIBIT_PID_PATH } from '../services/config.js';
+import { isTtydRunning, stopTtyd } from '../services/ttyd.js';
+import { sessionExists, attachSession } from '../services/tmux.js';
+import { removeHooks } from '../services/hooks.js';
+import { releaseSleep } from '../services/battery.js';
+import { killByPidFile, cleanupPidFile } from '../services/process.js';
+export async function unlink() {
+    // 1. Guard: must be linked
+    if (!isTtydRunning()) {
+        console.log(chalk.yellow('⚠  Pas de session linkée en cours.'));
+        return;
+    }
+    // 2. Stop ttyd
+    console.log(chalk.cyan('  Arrêt de ttyd…'));
+    try {
+        stopTtyd();
+        console.log(chalk.green('✔ ttyd arrêté.'));
+    }
+    catch {
+        console.log(chalk.yellow('⚠  Impossible d\'arrêter ttyd proprement.'));
+    }
+    // 3. Remove hooks
+    try {
+        removeHooks();
+        console.log(chalk.green('✔ Hooks Claude supprimés.'));
+    }
+    catch {
+        console.log(chalk.yellow('⚠  Impossible de supprimer les hooks Claude.'));
+    }
+    // 4. Release sleep inhibitor
+    try {
+        releaseSleep();
+        console.log(chalk.green('✔ Mise en veille réactivée.'));
+    }
+    catch {
+        console.log(chalk.yellow('⚠  Impossible de réactiver la mise en veille.'));
+    }
+    // 5. Kill battery watcher
+    killByPidFile(BATTERY_PID_PATH);
+    // 6. Clean PID files
+    cleanupPidFile(BATTERY_PID_PATH);
+    cleanupPidFile(INHIBIT_PID_PATH);
+    console.log();
+    console.log(chalk.bold.green('✔ Terminal unlinked.'));
+    console.log();
+    // 7. Attach tmux session if it exists
+    if (sessionExists()) {
+        console.log(chalk.gray('  La session tmux est toujours active. Connexion…'));
+        attachSession();
+    }
+}
+export default unlink;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+const program = new Command();
+program
+    .name('rms-devremote')
+    .description('Share your local terminal remotely with push notifications')
+    .version('2.0.0');
+// Helper: lazy-load a command module by path (relative to dist/)
+async function runCommand(modulePath) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mod = await import(modulePath);
+    await mod.default();
+}
+program
+    .command('setup')
+    .description('Configure the remote server (install ttyd, nginx, ntfy)')
+    .action(() => runCommand('./commands/setup.js'));
+program
+    .command('link')
+    .description('Link this machine to a remote server')
+    .action(() => runCommand('./commands/link.js'));
+program
+    .command('unlink')
+    .description('Unlink this machine from the remote server')
+    .action(() => runCommand('./commands/unlink.js'));
+program
+    .command('attach')
+    .description('Attach to a remote terminal session')
+    .action(() => runCommand('./commands/attach.js'));
+program
+    .command('status')
+    .description('Show the status of the remote connection')
+    .action(() => runCommand('./commands/status.js'));
+program
+    .command('ping')
+    .description('Ping the remote server to check connectivity')
+    .action(() => runCommand('./commands/ping.js'));
+program
+    .command('check')
+    .description('Check system requirements and dependencies')
+    .action(() => runCommand('./commands/check.js'));
+program
+    .command('clean')
+    .description('Remove all rms-devremote configuration and data')
+    .action(() => runCommand('./commands/clean.js'));
+// Default action: show dashboard when no command is provided
+if (process.argv.length <= 2) {
+    runCommand('./commands/dashboard.js').catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+else {
+    program.parse(process.argv);
+}

package/dist/server/auth.d.ts

@@ -0,0 +1,6 @@
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Express middleware: HTTP Basic Authentication.
+ * Credentials come from ~/.rms-devremote/.env (TTYD_USER / TTYD_PASSWORD).
+ */
+export declare function basicAuth(req: Request, res: Response, next: NextFunction): void;

package/dist/server/auth.js

@@ -0,0 +1,32 @@
+import { readEnv } from '../services/config.js';
+/**
+ * Express middleware: HTTP Basic Authentication.
+ * Credentials come from ~/.rms-devremote/.env (TTYD_USER / TTYD_PASSWORD).
+ */
+export function basicAuth(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Basic ')) {
+        res.setHeader('WWW-Authenticate', 'Basic realm="devremote"');
+        res.status(401).end('Authentication required');
+        return;
+    }
+    const encoded = authHeader.slice(6);
+    const decoded = Buffer.from(encoded, 'base64').toString('utf8');
+    const colonIdx = decoded.indexOf(':');
+    if (colonIdx === -1) {
+        res.status(401).end('Invalid credentials');
+        return;
+    }
+    const user = decoded.slice(0, colonIdx);
+    const pass = decoded.slice(colonIdx + 1);
+    const env = readEnv();
+    const expectedUser = env.TTYD_USER ?? 'admin';
+    const expectedPass = env.TTYD_PASSWORD ?? 'changeme';
+    if (user === expectedUser && pass === expectedPass) {
+        next();
+    }
+    else {
+        res.setHeader('WWW-Authenticate', 'Basic realm="devremote"');
+        res.status(401).end('Invalid credentials');
+    }
+}

package/dist/server/frontend.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates the complete frontend HTML for the devremote terminal PWA.
+ */
+export declare function buildFrontendHTML(): string;