rms-devremote 3.0.0

package/dist/services/docker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Check whether the Docker daemon is running.
+ */
+export declare function isDockerRunning(): boolean;
+/**
+ * Check whether the Compose stack is up (at least one service in 'running' state).
+ */
+export declare function isComposeUp(): boolean;
+/**
+ * Get the status of a named container.
+ */
+export declare function getContainerStatus(name: string): 'running' | 'stopped' | 'missing';
+/**
+ * Start the Compose stack in detached mode.
+ */
+export declare function composeUp(): void;
+/**
+ * Stop and remove the Compose stack.
+ */
+export declare function composeDown(): void;
+/**
+ * Execute a command inside a running container.
+ * Returns the stdout of the command.
+ */
+export declare function execInContainer(container: string, cmd: string[]): string;

package/dist/services/docker.js

@@ -0,0 +1,75 @@
+import { run } from './shell.js';
+import { spawnSync } from 'child_process';
+import { DOCKER_COMPOSE_PATH } from './config.js';
+/**
+ * Check whether the Docker daemon is running.
+ */
+export function isDockerRunning() {
+    try {
+        run('docker', ['info']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check whether the Compose stack is up (at least one service in 'running' state).
+ */
+export function isComposeUp() {
+    try {
+        const output = run('docker', [
+            'compose',
+            '-f', DOCKER_COMPOSE_PATH,
+            'ps',
+        ]);
+        return output.toLowerCase().includes('running');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the status of a named container.
+ */
+export function getContainerStatus(name) {
+    try {
+        const output = run('docker', [
+            'inspect',
+            '--format', '{{.State.Status}}',
+            name,
+        ]);
+        const status = output.trim().toLowerCase();
+        if (status === 'running')
+            return 'running';
+        return 'stopped';
+    }
+    catch {
+        return 'missing';
+    }
+}
+/**
+ * Start the Compose stack in detached mode.
+ */
+export function composeUp() {
+    const result = spawnSync('docker', ['compose', '-f', DOCKER_COMPOSE_PATH, 'up', '-d'], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        throw new Error('docker compose up failed');
+    }
+}
+/**
+ * Stop and remove the Compose stack.
+ */
+export function composeDown() {
+    const result = spawnSync('docker', ['compose', '-f', DOCKER_COMPOSE_PATH, 'down'], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        throw new Error('docker compose down failed');
+    }
+}
+/**
+ * Execute a command inside a running container.
+ * Returns the stdout of the command.
+ */
+export function execInContainer(container, cmd) {
+    return run('docker', ['exec', container, ...cmd]);
+}

package/dist/services/hooks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Merge devremote hooks into ~/.claude/settings.json.
+ * Adds PreToolUse, Notification and Stop hooks tagged with _source.
+ * Existing hooks from other sources are preserved.
+ */
+export declare function mergeHooks(): void;
+/**
+ * Remove all devremote hooks from ~/.claude/settings.json.
+ * Only entries tagged with _source: rms-devremote are removed.
+ */
+export declare function removeHooks(): void;
+/**
+ * Returns true if devremote hooks are present in ~/.claude/settings.json.
+ */
+export declare function hasDevremoteHooks(): boolean;

package/dist/services/hooks.js

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { NOTIFY_SCRIPT_PATH } from './config.js';
+const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const SOURCE_TAG = 'rms-devremote';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function readSettings() {
+    if (!existsSync(CLAUDE_SETTINGS_PATH)) {
+        return {};
+    }
+    const raw = readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    return JSON.parse(raw);
+}
+function writeSettings(settings) {
+    writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8');
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Merge devremote hooks into ~/.claude/settings.json.
+ * Adds PreToolUse, Notification and Stop hooks tagged with _source.
+ * Existing hooks from other sources are preserved.
+ */
+export function mergeHooks() {
+    const settings = readSettings();
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hookTypes = [
+        'Notification',
+        'Stop',
+    ];
+    // Map hook type to the event argument notify.sh expects
+    const eventMap = {
+        PreToolUse: 'tool-use',
+        Notification: 'notification',
+        Stop: 'stop',
+    };
+    for (const hookType of hookTypes) {
+        if (!settings.hooks[hookType]) {
+            settings.hooks[hookType] = [];
+        }
+        const entries = settings.hooks[hookType];
+        // Remove any pre-existing devremote entry for this hook type to avoid duplicates
+        const filtered = entries.map((entry) => ({
+            ...entry,
+            hooks: entry.hooks.filter((h) => h._source !== SOURCE_TAG),
+        }));
+        // Find or create the catch-all matcher entry
+        let catchAll = filtered.find((e) => !e.matcher || e.matcher === '*');
+        if (!catchAll) {
+            catchAll = { hooks: [] };
+            filtered.push(catchAll);
+        }
+        catchAll.hooks.push({
+            type: 'command',
+            command: `${NOTIFY_SCRIPT_PATH} ${eventMap[hookType]}`,
+            _source: SOURCE_TAG,
+        });
+        settings.hooks[hookType] = filtered;
+    }
+    writeSettings(settings);
+}
+/**
+ * Remove all devremote hooks from ~/.claude/settings.json.
+ * Only entries tagged with _source: rms-devremote are removed.
+ */
+export function removeHooks() {
+    if (!existsSync(CLAUDE_SETTINGS_PATH))
+        return;
+    const settings = readSettings();
+    if (!settings.hooks)
+        return;
+    for (const hookType of Object.keys(settings.hooks)) {
+        const entries = settings.hooks[hookType];
+        if (!Array.isArray(entries))
+            continue;
+        settings.hooks[hookType] = entries
+            .map((entry) => ({
+            ...entry,
+            hooks: entry.hooks.filter((h) => h._source !== SOURCE_TAG),
+        }))
+            .filter((entry) => entry.hooks.length > 0);
+    }
+    writeSettings(settings);
+}
+/**
+ * Returns true if devremote hooks are present in ~/.claude/settings.json.
+ */
+export function hasDevremoteHooks() {
+    if (!existsSync(CLAUDE_SETTINGS_PATH))
+        return false;
+    const settings = readSettings();
+    if (!settings.hooks)
+        return false;
+    for (const entries of Object.values(settings.hooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            for (const hook of entry.hooks) {
+                if (hook._source === SOURCE_TAG)
+                    return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/services/ntfy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Send a notification via the local ntfy instance.
+ * Uses HTTP basic auth with admin credentials from .env.
+ * Returns true on success, false on failure.
+ */
+export declare function sendNotification(body: string, priority?: string): Promise<boolean>;
+/**
+ * Check whether the ntfy container is healthy by calling its health endpoint.
+ * Returns true if the service responds with a 200-range status.
+ */
+export declare function healthCheck(): Promise<boolean>;
+/**
+ * Create the admin user inside the devremote-ntfy container.
+ */
+export declare function createAdminUser(password: string): void;
+/**
+ * Change the admin user password inside the devremote-ntfy container.
+ */
+export declare function changeAdminPassword(password: string): void;

package/dist/services/ntfy.js

@@ -0,0 +1,63 @@
+import { readConfig, readEnv } from './config.js';
+import { execInContainer } from './docker.js';
+/**
+ * Send a notification via the local ntfy instance.
+ * Uses HTTP basic auth with admin credentials from .env.
+ * Returns true on success, false on failure.
+ */
+export async function sendNotification(body, priority = 'default') {
+    const config = readConfig();
+    const env = readEnv();
+    const port = config.ntfy.port;
+    const topic = env.NTFY_TOPIC ?? 'devremote';
+    const password = env.NTFY_ADMIN_PASSWORD ?? 'changeme';
+    const credentials = Buffer.from(`admin:${password}`).toString('base64');
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/${topic}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Basic ${credentials}`,
+                Priority: priority,
+                'Content-Type': 'text/plain',
+            },
+            body,
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check whether the ntfy container is healthy by calling its health endpoint.
+ * Returns true if the service responds with a 200-range status.
+ */
+export async function healthCheck() {
+    const config = readConfig();
+    const port = config.ntfy.port;
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/v1/health`);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create the admin user inside the devremote-ntfy container.
+ */
+export function createAdminUser(password) {
+    execInContainer('devremote-ntfy', [
+        'sh', '-c',
+        `NTFY_PASSWORD=${password} ntfy user add --role=admin admin`,
+    ]);
+}
+/**
+ * Change the admin user password inside the devremote-ntfy container.
+ */
+export function changeAdminPassword(password) {
+    execInContainer('devremote-ntfy', [
+        'sh', '-c',
+        `NTFY_PASSWORD=${password} ntfy user change-pass admin`,
+    ]);
+}

package/dist/services/process.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Write a PID to a file.
+ */
+export declare function writePid(path: string, pid: number): void;
+/**
+ * Read a PID from a file.
+ * Returns the PID as a number, or null if the file does not exist or is invalid.
+ */
+export declare function readPid(path: string): number | null;
+/**
+ * Check whether a process with the given PID is currently running.
+ * Uses `kill -0` which sends no signal but checks for process existence.
+ */
+export declare function isProcessRunning(pid: number): boolean;
+/**
+ * Kill the process whose PID is stored in the given PID file.
+ * Returns true if a process was found and a SIGTERM was sent, false otherwise.
+ * The PID file is NOT removed — call cleanupPidFile() separately if needed.
+ */
+export declare function killByPidFile(path: string): boolean;
+/**
+ * Remove a PID file if it exists. Safe to call even when the file is absent.
+ */
+export declare function cleanupPidFile(path: string): void;
+/**
+ * Find the PID of the process listening on the given TCP port.
+ * Uses `lsof` to inspect open sockets.
+ * Returns the PID as a number, or null if no matching process is found.
+ */
+export declare function findProcessByPort(port: number): number | null;

package/dist/services/process.js

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { run } from './shell.js';
+// ---------------------------------------------------------------------------
+// PID file management
+// ---------------------------------------------------------------------------
+/**
+ * Write a PID to a file.
+ */
+export function writePid(path, pid) {
+    writeFileSync(path, String(pid), 'utf8');
+}
+/**
+ * Read a PID from a file.
+ * Returns the PID as a number, or null if the file does not exist or is invalid.
+ */
+export function readPid(path) {
+    if (!existsSync(path))
+        return null;
+    const raw = readFileSync(path, 'utf8').trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+}
+/**
+ * Check whether a process with the given PID is currently running.
+ * Uses `kill -0` which sends no signal but checks for process existence.
+ */
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Kill the process whose PID is stored in the given PID file.
+ * Returns true if a process was found and a SIGTERM was sent, false otherwise.
+ * The PID file is NOT removed — call cleanupPidFile() separately if needed.
+ */
+export function killByPidFile(path) {
+    const pid = readPid(path);
+    if (pid === null)
+        return false;
+    if (!isProcessRunning(pid))
+        return false;
+    try {
+        process.kill(pid, 'SIGTERM');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove a PID file if it exists. Safe to call even when the file is absent.
+ */
+export function cleanupPidFile(path) {
+    if (existsSync(path)) {
+        unlinkSync(path);
+    }
+}
+// ---------------------------------------------------------------------------
+// Port-based process lookup
+// ---------------------------------------------------------------------------
+/**
+ * Find the PID of the process listening on the given TCP port.
+ * Uses `lsof` to inspect open sockets.
+ * Returns the PID as a number, or null if no matching process is found.
+ */
+export function findProcessByPort(port) {
+    try {
+        const output = run('lsof', [
+            '-iTCP:' + port,
+            '-sTCP:LISTEN',
+            '-t',
+            '-n',
+            '-P',
+        ]);
+        // lsof -t may return multiple PIDs (one per line); take the first
+        const firstLine = output.split('\n')[0]?.trim();
+        if (!firstLine)
+            return null;
+        const pid = parseInt(firstLine, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/services/proxy-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/proxy-worker.js

@@ -0,0 +1,12 @@
+// Standalone worker: starts the reverse proxy in a long-running process.
+// Forked from the link command so it survives after link exits.
+import { startProxy } from './proxy.js';
+import { readConfig } from './config.js';
+const config = readConfig();
+const server = startProxy(config.ttyd.port);
+server.on('listening', () => {
+    // Signal parent that we're ready
+    if (process.send) {
+        process.send('ready');
+    }
+});

package/dist/services/proxy.d.ts

@@ -0,0 +1,4 @@
+import http from 'http';
+declare const INTERNAL_TTYD_PORT = 7691;
+export { INTERNAL_TTYD_PORT };
+export declare function startProxy(proxyPort: number): http.Server;

package/dist/services/proxy.js

@@ -0,0 +1,195 @@
+import http from 'http';
+import net from 'net';
+// ---------------------------------------------------------------------------
+// Toolbar HTML/CSS/JS injected before </body>
+// ---------------------------------------------------------------------------
+const TOOLBAR_INJECT = `
+<!-- devremote mobile toolbar -->
+<style>
+  :root { --tb-h: 96px; }
+  #devremote-toolbar {
+    position: fixed; bottom: 0; left: 0; right: 0;
+    height: var(--tb-h);
+    background: #1a1a2e;
+    border-top: 1px solid #2a2a4a;
+    display: flex; flex-direction: column;
+    justify-content: center; gap: 6px;
+    padding: 6px 8px; z-index: 9999;
+  }
+  #devremote-toolbar.hidden { display: none; }
+  #devremote-toolbar .tb-row { display: flex; gap: 6px; justify-content: center; }
+  #devremote-toolbar .tb-btn {
+    display: flex; align-items: center; justify-content: center;
+    flex: 1; max-width: 72px; height: 38px;
+    background: #16213e; border: 1px solid #2a2a4a;
+    border-radius: 8px; font-size: 14px; font-weight: 500;
+    color: #e0e0e0; cursor: pointer; user-select: none;
+    -webkit-tap-highlight-color: transparent;
+  }
+  #devremote-toolbar .tb-btn:active { background: #0f3460; transform: scale(0.93); }
+  #devremote-toolbar .tb-btn.accent {
+    background: #00d4aa; color: #0f0f23; font-weight: 600; border-color: #00d4aa;
+  }
+  #devremote-toolbar .tb-btn.accent:active { background: #00b894; }
+  #devremote-toolbar .tb-btn.quick { font-weight: 600; font-size: 16px; text-transform: uppercase; }
+  #devremote-toggle {
+    position: fixed; top: 6px; right: 6px; z-index: 10000;
+    background: #1a1a2e; border: 1px solid #2a2a4a; border-radius: 6px;
+    width: 32px; height: 32px;
+    display: flex; align-items: center; justify-content: center;
+    color: #888; font-size: 18px; cursor: pointer;
+    -webkit-tap-highlight-color: transparent;
+  }
+  #devremote-toggle:active { border-color: #00d4aa; color: #00d4aa; }
+</style>
+
+<button id="devremote-toggle" title="Toggle toolbar">&#x2699;</button>
+
+<div id="devremote-toolbar" role="toolbar">
+  <div class="tb-row">
+    <button class="tb-btn" data-key="ArrowUp">&#x25B2;</button>
+    <button class="tb-btn" data-key="ArrowDown">&#x25BC;</button>
+    <button class="tb-btn accent" data-key="Enter">Enter</button>
+    <button class="tb-btn" data-key="Escape">Esc</button>
+    <button class="tb-btn" data-key="Tab">Tab</button>
+  </div>
+  <div class="tb-row">
+    <button class="tb-btn quick" data-input="y">Y</button>
+    <button class="tb-btn quick" data-input="n">N</button>
+    <button class="tb-btn" data-key="c" data-ctrl="true">^C</button>
+    <button class="tb-btn" data-key="d" data-ctrl="true">^D</button>
+    <button class="tb-btn" data-key="z" data-ctrl="true">^Z</button>
+  </div>
+</div>
+
+<script>
+(function() {
+  var KEY_MAP = {
+    ArrowUp: '\\x1b[A', ArrowDown: '\\x1b[B',
+    ArrowLeft: '\\x1b[D', ArrowRight: '\\x1b[C',
+    Enter: '\\r', Escape: '\\x1b', Tab: '\\t'
+  };
+
+  function ctrlKey(k) { return String.fromCharCode(k.toUpperCase().charCodeAt(0) - 64); }
+
+  // Intercept WebSocket to capture ttyd connection
+  var ttydWs = null;
+  var Orig = window.WebSocket;
+  window.WebSocket = function() {
+    var ws = new (Function.prototype.bind.apply(Orig, [null].concat(Array.prototype.slice.call(arguments))))();
+    ttydWs = ws;
+    return ws;
+  };
+  window.WebSocket.prototype = Orig.prototype;
+  window.WebSocket.CONNECTING = 0;
+  window.WebSocket.OPEN = 1;
+  window.WebSocket.CLOSING = 2;
+  window.WebSocket.CLOSED = 3;
+
+  function sendInput(data) {
+    if (ttydWs && ttydWs.readyState === 1) {
+      var enc = new TextEncoder();
+      var payload = enc.encode(data);
+      var msg = new Uint8Array(payload.length + 1);
+      msg[0] = 0;
+      msg.set(payload, 1);
+      ttydWs.send(msg);
+    }
+  }
+
+  var btns = document.querySelectorAll('#devremote-toolbar .tb-btn');
+  for (var i = 0; i < btns.length; i++) {
+    (function(btn) {
+      btn.addEventListener('click', function(e) {
+        e.preventDefault();
+        var di = btn.getAttribute('data-input');
+        if (di) { sendInput(di + '\\r'); return; }
+        var key = btn.getAttribute('data-key');
+        var isCtrl = btn.getAttribute('data-ctrl') === 'true';
+        if (isCtrl && key) sendInput(ctrlKey(key));
+        else if (key && KEY_MAP[key]) sendInput(KEY_MAP[key]);
+      });
+      btn.addEventListener('contextmenu', function(e) { e.preventDefault(); });
+    })(btns[i]);
+  }
+
+  // Toggle
+  var toolbar = document.getElementById('devremote-toolbar');
+  document.getElementById('devremote-toggle').addEventListener('click', function() {
+    toolbar.classList.toggle('hidden');
+  });
+})();
+</script>
+`;
+// ---------------------------------------------------------------------------
+// Reverse proxy: injects toolbar into ttyd HTML, proxies WebSocket via TCP
+// ---------------------------------------------------------------------------
+const INTERNAL_TTYD_PORT = 7691;
+export { INTERNAL_TTYD_PORT };
+export function startProxy(proxyPort) {
+    const ttydPort = INTERNAL_TTYD_PORT;
+    const server = http.createServer((req, res) => {
+        const proxyReq = http.request({
+            hostname: '127.0.0.1',
+            port: ttydPort,
+            path: req.url,
+            method: req.method,
+            headers: { ...req.headers, host: `127.0.0.1:${ttydPort}`, 'accept-encoding': 'identity' },
+        }, (proxyRes) => {
+            const ct = proxyRes.headers['content-type'] ?? '';
+            if (req.url === '/' && ct.includes('text/html')) {
+                // Collect full response as buffer, then inject toolbar
+                const chunks = [];
+                proxyRes.on('data', (chunk) => { chunks.push(chunk); });
+                proxyRes.on('end', () => {
+                    let body = Buffer.concat(chunks).toString('utf8');
+                    body = body.replace('</body>', TOOLBAR_INJECT + '</body>');
+                    const headers = { ...proxyRes.headers };
+                    headers['content-length'] = String(Buffer.byteLength(body, 'utf8'));
+                    delete headers['content-encoding'];
+                    res.writeHead(proxyRes.statusCode ?? 200, headers);
+                    res.end(body, 'utf8');
+                });
+            }
+            else {
+                res.writeHead(proxyRes.statusCode ?? 200, proxyRes.headers);
+                proxyRes.pipe(res);
+            }
+        });
+        proxyReq.on('error', (err) => {
+            res.writeHead(502);
+            res.end('Proxy error');
+        });
+        req.pipe(proxyReq);
+    });
+    // WebSocket: raw TCP proxy for upgrade requests
+    server.on('upgrade', (req, clientSocket, head) => {
+        const ttydSocket = net.connect(ttydPort, '127.0.0.1', () => {
+            // Reconstruct the HTTP upgrade request to forward to ttyd
+            let rawReq = `${req.method} ${req.url} HTTP/1.1\r\n`;
+            for (let i = 0; i < req.rawHeaders.length; i += 2) {
+                const key = req.rawHeaders[i];
+                const val = req.rawHeaders[i + 1];
+                // Replace host header
+                if (key.toLowerCase() === 'host') {
+                    rawReq += `${key}: 127.0.0.1:${ttydPort}\r\n`;
+                }
+                else {
+                    rawReq += `${key}: ${val}\r\n`;
+                }
+            }
+            rawReq += '\r\n';
+            ttydSocket.write(rawReq);
+            if (head.length > 0) {
+                ttydSocket.write(head);
+            }
+            // Pipe in both directions
+            ttydSocket.pipe(clientSocket);
+            clientSocket.pipe(ttydSocket);
+        });
+        ttydSocket.on('error', () => clientSocket.destroy());
+        clientSocket.on('error', () => ttydSocket.destroy());
+    });
+    server.listen(proxyPort, '0.0.0.0');
+    return server;
+}

package/dist/services/shell.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Synchronously execute a command with arguments.
+ * Uses execFileSync to prevent shell injection.
+ * Returns trimmed stdout as a string.
+ */
+export declare function run(cmd: string, args: string[]): string;
+/**
+ * Asynchronously execute a command with arguments.
+ * Uses execFile (promisified) to prevent shell injection.
+ * Returns trimmed stdout as a string.
+ */
+export declare function runAsync(cmd: string, args: string[]): Promise<string>;
+/**
+ * Check whether a command exists in PATH.
+ * Returns true if found, false otherwise.
+ */
+export declare function which(cmd: string): boolean;
+/**
+ * Check whether a given port is currently in use.
+ * Uses lsof to inspect open files/sockets.
+ */
+export declare function isPortInUse(port: number): boolean;