rms-devremote 3.0.0

package/dist/services/shell.js

@@ -0,0 +1,47 @@
+import { execFileSync, execFile } from 'child_process';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
+/**
+ * Synchronously execute a command with arguments.
+ * Uses execFileSync to prevent shell injection.
+ * Returns trimmed stdout as a string.
+ */
+export function run(cmd, args) {
+    const result = execFileSync(cmd, args, { encoding: 'utf8' });
+    return result.trim();
+}
+/**
+ * Asynchronously execute a command with arguments.
+ * Uses execFile (promisified) to prevent shell injection.
+ * Returns trimmed stdout as a string.
+ */
+export async function runAsync(cmd, args) {
+    const { stdout } = await execFileAsync(cmd, args, { encoding: 'utf8' });
+    return stdout.trim();
+}
+/**
+ * Check whether a command exists in PATH.
+ * Returns true if found, false otherwise.
+ */
+export function which(cmd) {
+    try {
+        run('which', [cmd]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check whether a given port is currently in use.
+ * Uses lsof to inspect open files/sockets.
+ */
+export function isPortInUse(port) {
+    try {
+        run('lsof', ['-iTCP:' + port, '-sTCP:LISTEN', '-t']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/tmux.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Check whether tmux is installed in PATH.
+ */
+export declare function isTmuxInstalled(): boolean;
+/**
+ * Check whether the devremote tmux session exists.
+ */
+export declare function sessionExists(): boolean;
+/**
+ * Create the devremote tmux session in detached mode.
+ */
+export declare function createSession(): void;
+/**
+ * Attach to the devremote tmux session.
+ * Spawns tmux with stdio: 'inherit' and waits for the child to exit.
+ */
+export declare function attachSession(): void;
+/**
+ * Kill a tmux session by name (defaults to devremote).
+ */
+export declare function killSession(name?: string): void;
+/**
+ * List all tmux sessions that include the devremote session name.
+ * Returns an array of matching session name strings.
+ */
+export declare function listSessions(): string[];
+/**
+ * Return the configured session name.
+ */
+export declare function getSessionName(): string;

package/dist/services/tmux.js

@@ -0,0 +1,74 @@
+import { spawn } from 'child_process';
+import { run } from './shell.js';
+import { which } from './shell.js';
+const SESSION_NAME = 'devremote';
+/**
+ * Check whether tmux is installed in PATH.
+ */
+export function isTmuxInstalled() {
+    return which('tmux');
+}
+/**
+ * Check whether the devremote tmux session exists.
+ */
+export function sessionExists() {
+    try {
+        run('tmux', ['has-session', '-t', SESSION_NAME]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create the devremote tmux session in detached mode.
+ */
+export function createSession() {
+    run('tmux', ['new-session', '-d', '-s', SESSION_NAME]);
+}
+/**
+ * Attach to the devremote tmux session.
+ * Spawns tmux with stdio: 'inherit' and waits for the child to exit.
+ */
+export function attachSession() {
+    const child = spawn('tmux', ['attach-session', '-t', SESSION_NAME], {
+        stdio: 'inherit',
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+}
+/**
+ * Kill a tmux session by name (defaults to devremote).
+ */
+export function killSession(name) {
+    const target = name ?? SESSION_NAME;
+    try {
+        run('tmux', ['kill-session', '-t', target]);
+    }
+    catch {
+        // Session may not exist — silently ignore
+    }
+}
+/**
+ * List all tmux sessions that include the devremote session name.
+ * Returns an array of matching session name strings.
+ */
+export function listSessions() {
+    try {
+        const output = run('tmux', ['list-sessions', '-F', '#{session_name}']);
+        return output
+            .split('\n')
+            .map((s) => s.trim())
+            .filter((s) => s.includes(SESSION_NAME));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Return the configured session name.
+ */
+export function getSessionName() {
+    return SESSION_NAME;
+}

package/dist/services/ttyd.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Check whether the devremote server is currently running.
+ */
+export declare function isServerRunning(): boolean;
+/**
+ * Return the PID of the server process, or null.
+ */
+export declare function getServerPid(): number | null;
+/**
+ * Check whether the server port is available.
+ */
+export declare function checkPortAvailable(): {
+    available: boolean;
+    blockingPid?: number;
+};
+/**
+ * Start the devremote terminal server as a detached process.
+ * Returns the PID.
+ */
+export declare function startServer(): number;
+/**
+ * Stop the devremote server.
+ */
+export declare function stopServer(): void;
+export declare const isTtydRunning: typeof isServerRunning;
+export declare const startTtyd: typeof startServer;
+export declare const stopTtyd: typeof stopServer;
+export declare const getTtydPid: typeof getServerPid;

package/dist/services/ttyd.js

@@ -0,0 +1,71 @@
+import { spawn } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { isPortInUse } from './shell.js';
+import { findProcessByPort } from './process.js';
+import { readConfig } from './config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Check whether the devremote server is currently running.
+ */
+export function isServerRunning() {
+    const config = readConfig();
+    return isPortInUse(config.ttyd.port);
+}
+/**
+ * Return the PID of the server process, or null.
+ */
+export function getServerPid() {
+    const config = readConfig();
+    return findProcessByPort(config.ttyd.port);
+}
+/**
+ * Check whether the server port is available.
+ */
+export function checkPortAvailable() {
+    const config = readConfig();
+    const pid = findProcessByPort(config.ttyd.port);
+    if (pid === null) {
+        return { available: true };
+    }
+    return { available: false, blockingPid: pid };
+}
+/**
+ * Start the devremote terminal server as a detached process.
+ * Returns the PID.
+ */
+export function startServer() {
+    const serverEntry = resolve(__dirname, '..', 'server', 'index.js');
+    const child = spawn('node', [serverEntry], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+    });
+    child.unref();
+    const pid = child.pid;
+    if (pid === undefined) {
+        throw new Error('Failed to start devremote server: no PID returned');
+    }
+    return pid;
+}
+/**
+ * Stop the devremote server.
+ */
+export function stopServer() {
+    const config = readConfig();
+    const pid = findProcessByPort(config.ttyd.port);
+    if (pid !== null) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // Already dead
+        }
+    }
+}
+// Backwards-compatible aliases
+export const isTtydRunning = isServerRunning;
+export const startTtyd = startServer;
+export const stopTtyd = stopServer;
+export const getTtydPid = getServerPid;

package/dist/setup-server/routes.d.ts

@@ -0,0 +1,4 @@
+import type { Express } from 'express';
+import type { WebSocketServer } from 'ws';
+export declare function broadcast(wss: WebSocketServer, type: string, data?: unknown): void;
+export declare function setupRoutes(app: Express, wss: WebSocketServer): void;

package/dist/setup-server/routes.js

@@ -0,0 +1,177 @@
+import { randomBytes } from 'crypto';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { copyFileSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { hashSync } from 'bcryptjs';
+import { ensureDataDir, writeConfig, writeEnv, DOCKER_COMPOSE_PATH, NTFY_CONFIG_PATH, NOTIFY_SCRIPT_PATH, HOOKS_PATH, PIN_HASH_PATH, } from '../services/config.js';
+import { composeUp } from '../services/docker.js';
+import { createAdminUser, sendNotification } from '../services/ntfy.js';
+import { which } from '../services/shell.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ---------------------------------------------------------------------------
+// Broadcast helper
+// ---------------------------------------------------------------------------
+export function broadcast(wss, type, data = {}) {
+    const message = JSON.stringify({ type, data });
+    wss.clients.forEach((client) => {
+        if (client.readyState === 1 /* OPEN */) {
+            client.send(message);
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Route setup
+// ---------------------------------------------------------------------------
+export function setupRoutes(app, wss) {
+    // GET /api/prereqs — check system dependencies
+    app.get('/api/prereqs', (_req, res) => {
+        res.json({
+            docker: which('docker'),
+            tmux: which('tmux'),
+            ttyd: which('ttyd'),
+            claude: which('claude'),
+            jq: which('jq'),
+        });
+    });
+    // POST /api/setup — run setup steps
+    app.post('/api/setup', async (req, res) => {
+        try {
+            const { terminalDomain, notifyDomain, tunnelToken, ttydPassword, email, pin, } = req.body;
+            // Step 1: Preparation
+            broadcast(wss, 'status', { message: 'Preparation des fichiers...' });
+            // Step 2: Ensure data directory
+            ensureDataDir();
+            // Step 3: Generate ntfy credentials
+            const ntfyTopic = `devremote-${randomBytes(6).toString('hex')}`;
+            const ntfyPassword = randomBytes(8).toString('hex');
+            // Step 4: Write config.json
+            writeConfig({
+                domains: {
+                    terminal: terminalDomain,
+                    notify: notifyDomain,
+                },
+                ttyd: {
+                    port: 7681,
+                },
+                ntfy: {
+                    port: 2586,
+                },
+                battery: {
+                    lowThreshold: 20,
+                    checkInterval: 60,
+                },
+            });
+            // Step 5: Write .env
+            writeEnv({
+                CLOUDFLARE_TUNNEL_TOKEN: tunnelToken,
+                TERMINAL_DOMAIN: terminalDomain,
+                NOTIFY_DOMAIN: notifyDomain,
+                TTYD_USER: email,
+                TTYD_PASSWORD: ttydPassword,
+                NTFY_TOPIC: ntfyTopic,
+                NTFY_ADMIN_PASSWORD: ntfyPassword,
+                NTFY_PORT: '2586',
+            });
+            // Step 6: Copy docker-compose.yml
+            const repoDockerDir = resolve(__dirname, '..', '..', 'docker');
+            const srcCompose = resolve(repoDockerDir, 'docker-compose.yml');
+            copyFileSync(srcCompose, DOCKER_COMPOSE_PATH);
+            // Step 7: Write ntfy/server.yml with actual domain
+            const ntfyDir = resolve(NTFY_CONFIG_PATH, '..');
+            if (!existsSync(ntfyDir)) {
+                mkdirSync(ntfyDir, { recursive: true });
+            }
+            const ntfyServerYml = [
+                `# ntfy server configuration`,
+                `base-url: https://${notifyDomain}`,
+                `listen-http: ":80"`,
+                `auth-default-access: "deny-all"`,
+                `behind-proxy: true`,
+                `cache-file: "/var/cache/ntfy/cache.db"`,
+                `auth-file: "/var/lib/ntfy/user.db"`,
+                `enable-web: false`,
+            ].join('\n') + '\n';
+            writeFileSync(NTFY_CONFIG_PATH, ntfyServerYml, 'utf8');
+            // Step 8: Copy notify.sh and chmod 755
+            const repoScriptsDir = resolve(__dirname, '..', '..', 'scripts');
+            const srcNotify = resolve(repoScriptsDir, 'notify.sh');
+            copyFileSync(srcNotify, NOTIFY_SCRIPT_PATH);
+            // chmod 755
+            const { chmodSync } = await import('fs');
+            chmodSync(NOTIFY_SCRIPT_PATH, 0o755);
+            // Step 9: Write hooks.json template
+            const hooksTemplate = {
+                hooks: {
+                    PreToolUse: [
+                        {
+                            matcher: '',
+                            hooks: [
+                                {
+                                    type: 'command',
+                                    command: `${NOTIFY_SCRIPT_PATH} tool-use`,
+                                },
+                            ],
+                        },
+                    ],
+                    Notification: [
+                        {
+                            matcher: '',
+                            hooks: [
+                                {
+                                    type: 'command',
+                                    command: `${NOTIFY_SCRIPT_PATH} notification`,
+                                },
+                            ],
+                        },
+                    ],
+                    Stop: [
+                        {
+                            matcher: '',
+                            hooks: [
+                                {
+                                    type: 'command',
+                                    command: `${NOTIFY_SCRIPT_PATH} stop`,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+            writeFileSync(HOOKS_PATH, JSON.stringify(hooksTemplate, null, 2), 'utf8');
+            // Step 10: Hash PIN and save
+            const pinHash = hashSync(pin, 10);
+            writeFileSync(PIN_HASH_PATH, pinHash, 'utf8');
+            // Step 11: Start Docker
+            broadcast(wss, 'status', { message: 'Demarrage Docker...' });
+            composeUp();
+            // Step 12: Wait 5 seconds
+            await new Promise((r) => setTimeout(r, 5000));
+            // Step 13: Create ntfy admin user
+            broadcast(wss, 'status', { message: 'Creation utilisateur ntfy...' });
+            createAdminUser(ntfyPassword);
+            // Step 14: Done
+            broadcast(wss, 'complete', {});
+            res.json({ ok: true, ntfyTopic, ntfyPassword, notifyDomain });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            broadcast(wss, 'error', { message });
+            res.status(500).json({ ok: false, error: message });
+        }
+    });
+    // POST /api/test-notification — send a test notification
+    app.post('/api/test-notification', async (_req, res) => {
+        try {
+            const ok = await sendNotification('Test rms-devremote -- les notifications marchent !');
+            res.json({ ok });
+        }
+        catch {
+            res.json({ ok: false });
+        }
+    });
+    // POST /api/done — signal setup complete
+    app.post('/api/done', (_req, res) => {
+        res.json({ ok: true });
+    });
+}

package/dist/setup-server/server.d.ts

@@ -0,0 +1,4 @@
+export declare function getSetupUrl(): string;
+export declare function startSetupServer(): Promise<{
+    close: () => void;
+}>;

package/dist/setup-server/server.js

@@ -0,0 +1,32 @@
+import { createServer } from 'http';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { setupRoutes } from './routes.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PORT = 3456;
+export function getSetupUrl() {
+    return `http://localhost:${PORT}`;
+}
+export async function startSetupServer() {
+    const app = express();
+    app.use(express.json());
+    // Serve static files from src/setup-server/public/
+    // When running from dist/, go up two levels to reach the source tree
+    const publicDir = resolve(__dirname, '..', '..', 'src', 'setup-server', 'public');
+    app.use(express.static(publicDir));
+    const httpServer = createServer(app);
+    const wss = new WebSocketServer({ server: httpServer });
+    setupRoutes(app, wss);
+    await new Promise((resolvePromise) => {
+        httpServer.listen(PORT, '127.0.0.1', () => resolvePromise());
+    });
+    return {
+        close: () => {
+            httpServer.close();
+            wss.close();
+        },
+    };
+}

package/docker/docker-compose.yml

@@ -0,0 +1,24 @@
+services:
+  tunnel:
+    image: cloudflare/cloudflared:latest
+    container_name: devremote-tunnel
+    restart: unless-stopped
+    command: tunnel run
+    environment:
+      - TUNNEL_TOKEN=${CLOUDFLARE_TUNNEL_TOKEN}
+
+  ntfy:
+    image: binwiederhier/ntfy:latest
+    container_name: devremote-ntfy
+    restart: unless-stopped
+    command: serve
+    ports:
+      - "127.0.0.1:${NTFY_PORT:-2586}:80"
+    volumes:
+      - ./ntfy/server.yml:/etc/ntfy/server.yml:ro
+      - ntfy-cache:/var/cache/ntfy
+      - ntfy-auth:/var/lib/ntfy
+
+volumes:
+  ntfy-cache:
+  ntfy-auth:

package/docker/ntfy/server.yml

@@ -0,0 +1,6 @@
+listen-http: ":80"
+auth-default-access: "deny-all"
+behind-proxy: true
+cache-file: "/var/cache/ntfy/cache.db"
+auth-file: "/var/lib/ntfy/user.db"
+enable-web: false

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "rms-devremote",
+  "version": "3.0.0",
+  "description": "Control your terminal remotely from your phone — mobile PWA with push notifications and zero open ports",
+  "type": "module",
+  "bin": {
+    "rms-devremote": "./dist/index.js",
+    "rdr": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "docker/",
+    "scripts/",
+    "src/setup-server/public/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "terminal",
+    "remote",
+    "tmux",
+    "mobile",
+    "pwa",
+    "xterm",
+    "claude",
+    "notifications"
+  ],
+  "author": "RMS Tech Studio",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RMS-Tech-Studio/claude-remote.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
+    "bcryptjs": "^3.0.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3",
+    "node-pty": "^1.1.0",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^3.0.0",
+    "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.5.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^6.0.2"
+  }
+}