claude-remote-cli 0.3.0 → 1.1.0

package/dist/bin/claude-remote-cli.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import * as service from '../server/service.js';
+import { DEFAULTS } from '../server/config.js';
+const require = createRequire(import.meta.url);
+// Parse CLI flags
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`Usage: claude-remote-cli [options]
+       claude-remote-cli <command>
+
+Commands:
+  install            Install as a background service (survives reboot)
+  uninstall          Stop and remove the background service
+  status             Show whether the service is running
+
+Options:
+  --bg               Shortcut: install and start as background service
+  --port <port>      Override server port (default: 3456)
+  --host <host>      Override bind address (default: 0.0.0.0)
+  --config <path>    Path to config.json (default: ~/.config/claude-remote-cli/config.json)
+  --version, -v      Show version
+  --help, -h         Show this help`);
+    process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+    process.exit(0);
+}
+function getArg(flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function resolveConfigPath() {
+    const explicit = getArg('--config');
+    if (explicit)
+        return explicit;
+    return path.join(service.CONFIG_DIR, 'config.json');
+}
+function runServiceCommand(fn) {
+    try {
+        fn();
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+const command = args[0];
+if (command === 'install' || command === 'uninstall' || command === 'status' || args.includes('--bg')) {
+    if (command === 'uninstall') {
+        runServiceCommand(() => { service.uninstall(); });
+    }
+    else if (command === 'status') {
+        runServiceCommand(() => {
+            const st = service.status();
+            if (!st.installed) {
+                console.log('Service is not installed.');
+            }
+            else if (st.running) {
+                console.log('Service is installed and running.');
+            }
+            else {
+                console.log('Service is installed but not running.');
+            }
+        });
+    }
+    else {
+        runServiceCommand(() => {
+            service.install({
+                configPath: resolveConfigPath(),
+                port: getArg('--port') ?? String(DEFAULTS.port),
+                host: getArg('--host') ?? DEFAULTS.host,
+            });
+        });
+    }
+}
+const configPath = resolveConfigPath();
+const configDir = path.dirname(configPath);
+// Ensure config directory exists
+if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+}
+// Pass config path and CLI overrides to the server
+process.env['CLAUDE_REMOTE_CONFIG'] = configPath;
+const portArg = getArg('--port');
+if (portArg !== undefined)
+    process.env['CLAUDE_REMOTE_PORT'] = portArg;
+const hostArg = getArg('--host');
+if (hostArg !== undefined)
+    process.env['CLAUDE_REMOTE_HOST'] = hostArg;
+await import('../server/index.js');

package/dist/server/auth.js

@@ -0,0 +1,41 @@
+import bcrypt from 'bcrypt';
+import crypto from 'node:crypto';
+const SALT_ROUNDS = 10;
+const MAX_ATTEMPTS = 5;
+const LOCKOUT_DURATION_MS = 15 * 60 * 1000; // 15 minutes
+const attemptMap = new Map();
+export async function hashPin(pin) {
+    return bcrypt.hash(pin, SALT_ROUNDS);
+}
+export async function verifyPin(pin, hash) {
+    return bcrypt.compare(pin, hash);
+}
+export function isRateLimited(ip) {
+    const entry = attemptMap.get(ip);
+    if (!entry)
+        return false;
+    if (entry.lockedUntil) {
+        if (Date.now() < entry.lockedUntil) {
+            return true;
+        }
+        attemptMap.delete(ip);
+    }
+    return false;
+}
+export function recordFailedAttempt(ip) {
+    const entry = attemptMap.get(ip) ?? { count: 0, lockedUntil: null };
+    entry.count += 1;
+    if (entry.count >= MAX_ATTEMPTS) {
+        entry.lockedUntil = Date.now() + LOCKOUT_DURATION_MS;
+    }
+    attemptMap.set(ip, entry);
+}
+export function clearRateLimit(ip) {
+    attemptMap.delete(ip);
+}
+export function generateCookieToken() {
+    return crypto.randomBytes(32).toString('hex');
+}
+export function _resetForTesting() {
+    attemptMap.clear();
+}

package/dist/server/config.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+export const DEFAULTS = {
+    host: '0.0.0.0',
+    port: 3456,
+    cookieTTL: '24h',
+    repos: [],
+    claudeCommand: 'claude',
+    claudeArgs: [],
+};
+export function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULTS, ...parsed };
+}
+export function saveConfig(configPath, config) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}

package/dist/server/index.js

@@ -0,0 +1,296 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline';
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import { loadConfig, saveConfig, DEFAULTS } from './config.js';
+import * as auth from './auth.js';
+import * as sessions from './sessions.js';
+import { setupWebSocket } from './ws.js';
+import { WorktreeWatcher } from './watcher.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// When run via CLI bin, config lives in ~/.config/claude-remote-cli/
+// When run directly (development), fall back to local config.json
+const CONFIG_PATH = process.env.CLAUDE_REMOTE_CONFIG || path.join(__dirname, '..', 'config.json');
+function parseTTL(ttl) {
+    if (typeof ttl !== 'string')
+        return 24 * 60 * 60 * 1000;
+    const match = ttl.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return 24 * 60 * 60 * 1000;
+    const value = parseInt(match[1], 10);
+    switch (match[2]) {
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        case 'd': return value * 24 * 60 * 60 * 1000;
+        default: return 24 * 60 * 60 * 1000;
+    }
+}
+function promptPin(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function scanReposInRoot(rootDir) {
+    const repos = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(rootDir, { withFileTypes: true });
+    }
+    catch (_) {
+        return repos;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
+            continue;
+        const fullPath = path.join(rootDir, entry.name);
+        if (fs.existsSync(path.join(fullPath, '.git'))) {
+            repos.push({ name: entry.name, path: fullPath, root: rootDir });
+        }
+    }
+    return repos;
+}
+function scanAllRepos(rootDirs) {
+    const repos = [];
+    for (const rootDir of rootDirs) {
+        repos.push(...scanReposInRoot(rootDir));
+    }
+    return repos;
+}
+async function main() {
+    let config;
+    try {
+        config = loadConfig(CONFIG_PATH);
+    }
+    catch (_) {
+        config = { ...DEFAULTS };
+        saveConfig(CONFIG_PATH, config);
+    }
+    // CLI flag overrides
+    if (process.env.CLAUDE_REMOTE_PORT)
+        config.port = parseInt(process.env.CLAUDE_REMOTE_PORT, 10);
+    if (process.env.CLAUDE_REMOTE_HOST)
+        config.host = process.env.CLAUDE_REMOTE_HOST;
+    if (!config.pinHash) {
+        const pin = await promptPin('Set up a PIN for claude-remote-cli:');
+        config.pinHash = await auth.hashPin(pin);
+        saveConfig(CONFIG_PATH, config);
+        console.log('PIN set successfully.');
+    }
+    const authenticatedTokens = new Set();
+    const app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use(express.static(path.join(__dirname, '..', 'public')));
+    const requireAuth = (req, res, next) => {
+        const token = req.cookies && req.cookies.token;
+        if (!token || !authenticatedTokens.has(token)) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+        next();
+    };
+    const watcher = new WorktreeWatcher();
+    watcher.rebuild(config.rootDirs || []);
+    const server = http.createServer(app);
+    const { broadcastEvent } = setupWebSocket(server, authenticatedTokens, watcher);
+    // POST /auth
+    app.post('/auth', async (req, res) => {
+        const ip = (req.ip || req.connection.remoteAddress);
+        if (auth.isRateLimited(ip)) {
+            res.status(429).json({ error: 'Too many attempts. Try again later.' });
+            return;
+        }
+        const { pin } = req.body;
+        if (!pin) {
+            res.status(400).json({ error: 'PIN required' });
+            return;
+        }
+        const valid = await auth.verifyPin(pin, config.pinHash);
+        if (!valid) {
+            auth.recordFailedAttempt(ip);
+            res.status(401).json({ error: 'Invalid PIN' });
+            return;
+        }
+        auth.clearRateLimit(ip);
+        const token = auth.generateCookieToken();
+        authenticatedTokens.add(token);
+        const ttlMs = parseTTL(config.cookieTTL);
+        setTimeout(() => authenticatedTokens.delete(token), ttlMs);
+        res.cookie('token', token, {
+            httpOnly: true,
+            sameSite: 'strict',
+            maxAge: ttlMs,
+        });
+        res.json({ ok: true });
+    });
+    // GET /sessions
+    app.get('/sessions', requireAuth, (_req, res) => {
+        res.json(sessions.list());
+    });
+    // GET /repos — scan root dirs for repos
+    app.get('/repos', requireAuth, (_req, res) => {
+        const repos = scanAllRepos(config.rootDirs || []);
+        // Also include legacy manually-added repos
+        if (config.repos) {
+            for (const repo of config.repos) {
+                if (!repos.some((r) => r.path === repo.path)) {
+                    repos.push(repo);
+                }
+            }
+        }
+        res.json(repos);
+    });
+    // GET /worktrees?repo=<path> — list worktrees; omit repo to scan all repos in all rootDirs
+    app.get('/worktrees', requireAuth, (req, res) => {
+        const repoParam = typeof req.query.repo === 'string' ? req.query.repo : undefined;
+        const roots = config.rootDirs || [];
+        const worktrees = [];
+        let reposToScan;
+        if (repoParam) {
+            const root = roots.find(function (r) { return repoParam.startsWith(r); }) || '';
+            reposToScan = [{ path: repoParam, name: repoParam.split('/').filter(Boolean).pop() || '', root }];
+        }
+        else {
+            reposToScan = scanAllRepos(roots);
+        }
+        for (const repo of reposToScan) {
+            const worktreeDir = path.join(repo.path, '.claude', 'worktrees');
+            let entries;
+            try {
+                entries = fs.readdirSync(worktreeDir, { withFileTypes: true });
+            }
+            catch (_) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                worktrees.push({
+                    name: entry.name,
+                    path: path.join(worktreeDir, entry.name),
+                    repoName: repo.name,
+                    repoPath: repo.path,
+                    root: repo.root,
+                });
+            }
+        }
+        res.json(worktrees);
+    });
+    // GET /roots — list root directories
+    app.get('/roots', requireAuth, (_req, res) => {
+        res.json(config.rootDirs || []);
+    });
+    // POST /roots — add a root directory
+    app.post('/roots', requireAuth, (req, res) => {
+        const { path: rootPath } = req.body;
+        if (!rootPath) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        if (!config.rootDirs)
+            config.rootDirs = [];
+        if (config.rootDirs.includes(rootPath)) {
+            res.status(409).json({ error: 'Root already exists' });
+            return;
+        }
+        config.rootDirs.push(rootPath);
+        saveConfig(CONFIG_PATH, config);
+        watcher.rebuild(config.rootDirs);
+        broadcastEvent('worktrees-changed');
+        res.status(201).json(config.rootDirs);
+    });
+    // DELETE /roots — remove a root directory
+    app.delete('/roots', requireAuth, (req, res) => {
+        const { path: rootPath } = req.body;
+        if (!rootPath || !config.rootDirs) {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        config.rootDirs = config.rootDirs.filter((r) => r !== rootPath);
+        saveConfig(CONFIG_PATH, config);
+        watcher.rebuild(config.rootDirs);
+        broadcastEvent('worktrees-changed');
+        res.json(config.rootDirs);
+    });
+    // POST /sessions
+    app.post('/sessions', requireAuth, (req, res) => {
+        const { repoPath, repoName, worktreePath, claudeArgs } = req.body;
+        if (!repoPath) {
+            res.status(400).json({ error: 'repoPath is required' });
+            return;
+        }
+        const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
+        const baseArgs = claudeArgs || config.claudeArgs || [];
+        // Compute root by matching repoPath against configured rootDirs
+        const roots = config.rootDirs || [];
+        const root = roots.find(function (r) { return repoPath.startsWith(r); }) || '';
+        let args;
+        let cwd;
+        let worktreeName;
+        if (worktreePath) {
+            // Resume existing worktree — run claude inside the worktree directory
+            args = [...baseArgs];
+            cwd = worktreePath;
+            worktreeName = worktreePath.split('/').pop() || '';
+        }
+        else {
+            // New worktree
+            worktreeName = 'mobile-' + name + '-' + Date.now().toString(36);
+            args = ['--worktree', worktreeName, ...baseArgs];
+            cwd = repoPath;
+        }
+        const session = sessions.create({
+            repoName: name,
+            repoPath: cwd,
+            root,
+            worktreeName,
+            displayName: worktreeName,
+            command: config.claudeCommand,
+            args,
+        });
+        res.status(201).json(session);
+    });
+    // DELETE /sessions/:id
+    app.delete('/sessions/:id', requireAuth, (req, res) => {
+        try {
+            sessions.kill(req.params['id']);
+            res.json({ ok: true });
+        }
+        catch (_) {
+            res.status(404).json({ error: 'Session not found' });
+        }
+    });
+    // PATCH /sessions/:id — update displayName and send /rename through PTY
+    app.patch('/sessions/:id', requireAuth, (req, res) => {
+        const { displayName } = req.body;
+        if (!displayName) {
+            res.status(400).json({ error: 'displayName is required' });
+            return;
+        }
+        try {
+            const id = req.params['id'];
+            const updated = sessions.updateDisplayName(id, displayName);
+            const session = sessions.get(id);
+            if (session && session.pty) {
+                session.pty.write('/rename "' + displayName.replace(/"/g, '\\"') + '"\r');
+            }
+            res.json(updated);
+        }
+        catch (_) {
+            res.status(404).json({ error: 'Session not found' });
+        }
+    });
+    server.listen(config.port, config.host, () => {
+        console.log(`claude-remote-cli listening on ${config.host}:${config.port}`);
+    });
+}
+main().catch(console.error);

package/dist/server/service.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { DEFAULTS } from './config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SERVICE_LABEL = 'com.claude-remote-cli';
+const HOME = process.env.HOME || process.env.USERPROFILE || '~';
+const CONFIG_DIR = path.join(HOME, '.config', 'claude-remote-cli');
+function getPlatform() {
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'linux')
+        return 'linux';
+    throw new Error('Unsupported platform: ' + process.platform + '. Only macOS and Linux are supported.');
+}
+function getServicePaths() {
+    const platform = getPlatform();
+    if (platform === 'macos') {
+        return {
+            servicePath: path.join(HOME, 'Library', 'LaunchAgents', SERVICE_LABEL + '.plist'),
+            logDir: path.join(CONFIG_DIR, 'logs'),
+            label: SERVICE_LABEL,
+        };
+    }
+    return {
+        servicePath: path.join(HOME, '.config', 'systemd', 'user', 'claude-remote-cli.service'),
+        logDir: null,
+        label: 'claude-remote-cli',
+    };
+}
+function generateServiceFile(platform, opts) {
+    const { nodePath, scriptPath, configPath, port, host, logDir } = opts;
+    if (platform === 'macos') {
+        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>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>--config</string>
+    <string>${configPath}</string>
+    <string>--port</string>
+    <string>${port}</string>
+    <string>--host</string>
+    <string>${host}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${path.join(logDir, 'stdout.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(logDir, 'stderr.log')}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH}</string>
+  </dict>
+</dict>
+</plist>`;
+    }
+    return `[Unit]
+Description=Claude Remote CLI
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath} --config ${configPath} --port ${port} --host ${host}
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${process.env.PATH}
+
+[Install]
+WantedBy=default.target`;
+}
+function isInstalled() {
+    const { servicePath } = getServicePaths();
+    return fs.existsSync(servicePath);
+}
+function install(opts) {
+    const platform = getPlatform();
+    const { servicePath, logDir } = getServicePaths();
+    if (isInstalled()) {
+        throw new Error('Service is already installed. Run `claude-remote-cli uninstall` first.');
+    }
+    const nodePath = process.execPath;
+    const scriptPath = path.resolve(__dirname, '..', 'bin', 'claude-remote-cli.js');
+    const configPath = opts.configPath || path.join(CONFIG_DIR, 'config.json');
+    const port = opts.port || String(DEFAULTS.port);
+    const host = opts.host || DEFAULTS.host;
+    const content = generateServiceFile(platform, { nodePath, scriptPath, configPath, port, host, logDir });
+    fs.mkdirSync(path.dirname(servicePath), { recursive: true });
+    if (logDir)
+        fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(servicePath, content, 'utf8');
+    if (platform === 'macos') {
+        execSync('launchctl load -w ' + servicePath, { stdio: 'inherit' });
+    }
+    else {
+        execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+        execSync('systemctl --user enable --now claude-remote-cli', { stdio: 'inherit' });
+    }
+    console.log('Service installed and started.');
+    if (logDir) {
+        console.log('Logs: ' + logDir);
+    }
+    else {
+        console.log('Logs: journalctl --user -u claude-remote-cli -f');
+    }
+}
+function uninstall() {
+    const platform = getPlatform();
+    const { servicePath } = getServicePaths();
+    if (!isInstalled()) {
+        throw new Error('Service is not installed.');
+    }
+    if (platform === 'macos') {
+        try {
+            execSync('launchctl unload ' + servicePath, { stdio: 'inherit' });
+        }
+        catch (_) {
+            // Ignore errors from already-unloaded services
+        }
+    }
+    else {
+        try {
+            execSync('systemctl --user disable --now claude-remote-cli', { stdio: 'inherit' });
+        }
+        catch (_) {
+            // Ignore errors from already-disabled services
+        }
+    }
+    fs.unlinkSync(servicePath);
+    console.log('Service uninstalled.');
+}
+function status() {
+    const platform = getPlatform();
+    if (!isInstalled()) {
+        return { installed: false, running: false };
+    }
+    const running = checkRunning(platform);
+    return { installed: true, running };
+}
+function checkRunning(platform) {
+    if (platform === 'macos') {
+        try {
+            const out = execSync('launchctl list ' + SERVICE_LABEL, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            return !out.includes('"LastExitStatus" = -1');
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    try {
+        execSync('systemctl --user is-active claude-remote-cli', { stdio: ['pipe', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+export { getPlatform, getServicePaths, generateServiceFile, isInstalled, install, uninstall, status, SERVICE_LABEL, CONFIG_DIR };