remote-cli-agent 0.1.0

package/dist/connection.d.ts

@@ -0,0 +1,3 @@
+export declare function connect(url: string, token: string): void;
+export declare function disconnect(): void;
+export declare function getConnectionStatus(): boolean;

package/dist/connection.js

@@ -0,0 +1,116 @@
+import WebSocket from 'ws';
+import { getSessionList, writeToSession, resizeSession, attachSession, spawnSession, setOutputHandler, setSessionsChangeHandler } from './terminal.js';
+let ws = null;
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_DELAY = 30000;
+const BASE_RECONNECT_DELAY = 1000;
+let serverUrl = '';
+let agentToken = '';
+let isConnected = false;
+export function connect(url, token) {
+    serverUrl = url;
+    agentToken = token;
+    // Setup terminal handlers
+    setOutputHandler((sessionId, data) => {
+        sendMessage({ type: 'output', sessionId, data });
+    });
+    setSessionsChangeHandler(() => {
+        sendMessage({ type: 'sessions_update', sessions: getSessionList() });
+    });
+    doConnect();
+}
+function doConnect() {
+    if (ws) {
+        ws.removeAllListeners();
+        ws.close();
+    }
+    const wsUrl = `${serverUrl}/ws/agent?token=${encodeURIComponent(agentToken)}`;
+    console.log(`Connecting to ${serverUrl}...`);
+    ws = new WebSocket(wsUrl);
+    ws.on('open', () => {
+        console.log('Connected to server');
+        isConnected = true;
+        reconnectAttempts = 0;
+        // Register current sessions
+        sendMessage({ type: 'register', sessions: getSessionList() });
+    });
+    ws.on('message', (data) => {
+        try {
+            const msg = JSON.parse(data.toString());
+            handleMessage(msg);
+        }
+        catch (err) {
+            console.error('Failed to parse server message:', err);
+        }
+    });
+    ws.on('close', (code, reason) => {
+        console.log(`Disconnected from server (code: ${code}, reason: ${reason.toString() || 'unknown'})`);
+        isConnected = false;
+        scheduleReconnect();
+    });
+    ws.on('error', (err) => {
+        console.error('WebSocket error:', err.message);
+        isConnected = false;
+    });
+}
+function handleMessage(msg) {
+    switch (msg.type) {
+        case 'input': {
+            writeToSession(msg.sessionId, msg.data);
+            break;
+        }
+        case 'resize': {
+            resizeSession(msg.sessionId, msg.cols, msg.rows);
+            break;
+        }
+        case 'attach': {
+            const exists = attachSession(msg.sessionId);
+            if (!exists) {
+                console.warn(`Session ${msg.sessionId} not found for attach`);
+            }
+            break;
+        }
+        case 'spawn': {
+            const command = msg.command || undefined;
+            const session = spawnSession(command);
+            console.log(`Spawned session: ${session.name} (${session.id})`);
+            // Notify server of updated sessions
+            sendMessage({ type: 'sessions_update', sessions: getSessionList() });
+            break;
+        }
+        default:
+            console.warn('Unknown message type from server:', msg.type);
+    }
+}
+function sendMessage(msg) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+    }
+}
+function scheduleReconnect() {
+    if (reconnectTimer)
+        return;
+    const delay = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, reconnectAttempts), MAX_RECONNECT_DELAY);
+    reconnectAttempts++;
+    console.log(`Reconnecting in ${delay / 1000}s (attempt ${reconnectAttempts})...`);
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        doConnect();
+    }, delay);
+}
+export function disconnect() {
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+    if (ws) {
+        ws.removeAllListeners();
+        ws.close(1000, 'Agent shutting down');
+        ws = null;
+    }
+    isConnected = false;
+}
+export function getConnectionStatus() {
+    return isConnected;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { connect, disconnect } from './connection.js';
+import { listTmuxSessions, attachTmuxSession, spawnSession, cleanupAll, getSessionList } from './terminal.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.remote-cli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function saveConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    fs.chmodSync(CONFIG_FILE, 0o600);
+}
+const program = new Command();
+program
+    .name('remote-cli')
+    .description('Remote CLI agent - connects local terminal sessions to the remote server')
+    .version('1.0.0');
+program
+    .command('configure')
+    .description('Configure the agent with server URL and token')
+    .requiredOption('-s, --server <url>', 'Server URL (e.g., https://remote-cli.example.com)')
+    .requiredOption('-t, --token <token>', 'Agent token from the web UI')
+    .action((opts) => {
+    const server = opts.server.replace(/\/$/, ''); // Remove trailing slash
+    saveConfig({ server, token: opts.token });
+    console.log(`Configuration saved to ${CONFIG_FILE}`);
+    console.log(`Server: ${server}`);
+    console.log(`Token: ${opts.token.slice(0, 8)}...`);
+});
+program
+    .command('connect')
+    .description('Connect to the server and register available sessions')
+    .option('-s, --server <url>', 'Server URL (overrides config)')
+    .option('-t, --token <token>', 'Agent token (overrides config)')
+    .option('--spawn [command]', 'Spawn a new session on connect')
+    .action((opts) => {
+    const config = loadConfig();
+    const server = opts.server || config?.server;
+    const token = opts.token || config?.token;
+    if (!server || !token) {
+        console.error('Error: Server URL and token are required.');
+        console.error('Run "remote-cli configure -s <url> -t <token>" first, or pass --server and --token flags.');
+        process.exit(1);
+    }
+    // Convert http(s) to ws(s) for WebSocket connection
+    const wsUrl = server.replace(/^http/, 'ws');
+    console.log(`Connecting to ${server}...`);
+    // List tmux sessions
+    const tmuxSessions = listTmuxSessions();
+    if (tmuxSessions.length > 0) {
+        console.log(`Found ${tmuxSessions.length} tmux session(s):`);
+        tmuxSessions.forEach(s => console.log(`  - ${s}`));
+        // Auto-attach all tmux sessions
+        for (const sessionName of tmuxSessions) {
+            attachTmuxSession(sessionName);
+        }
+    }
+    // Spawn a session if requested
+    if (opts.spawn !== undefined) {
+        const command = typeof opts.spawn === 'string' ? opts.spawn : undefined;
+        spawnSession(command);
+    }
+    // If no sessions available, spawn a default one
+    if (getSessionList().length === 0) {
+        console.log('No tmux sessions found. Spawning a default shell session...');
+        spawnSession();
+    }
+    // Connect to server
+    connect(wsUrl, token);
+    // Handle shutdown
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        disconnect();
+        cleanupAll();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Keep process alive
+    setInterval(() => { }, 1000);
+});
+program
+    .command('attach <session>')
+    .description('Attach a tmux session and connect to server')
+    .option('-s, --server <url>', 'Server URL')
+    .option('-t, --token <token>', 'Agent token')
+    .action((sessionName, opts) => {
+    const config = loadConfig();
+    const server = opts.server || config?.server;
+    const token = opts.token || config?.token;
+    if (!server || !token) {
+        console.error('Error: Server URL and token are required.');
+        process.exit(1);
+    }
+    const wsUrl = server.replace(/^http/, 'ws');
+    const session = attachTmuxSession(sessionName);
+    if (!session) {
+        console.error(`Failed to attach tmux session "${sessionName}"`);
+        const available = listTmuxSessions();
+        if (available.length > 0) {
+            console.log('Available tmux sessions:');
+            available.forEach(s => console.log(`  - ${s}`));
+        }
+        else {
+            console.log('No tmux sessions available.');
+        }
+        process.exit(1);
+    }
+    connect(wsUrl, token);
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        disconnect();
+        cleanupAll();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    setInterval(() => { }, 1000);
+});
+program
+    .command('spawn [command]')
+    .description('Spawn a new PTY session and connect to server')
+    .option('-s, --server <url>', 'Server URL')
+    .option('-t, --token <token>', 'Agent token')
+    .action((command, opts) => {
+    const config = loadConfig();
+    const server = opts.server || config?.server;
+    const token = opts.token || config?.token;
+    if (!server || !token) {
+        console.error('Error: Server URL and token are required.');
+        process.exit(1);
+    }
+    const wsUrl = server.replace(/^http/, 'ws');
+    spawnSession(command);
+    connect(wsUrl, token);
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        disconnect();
+        cleanupAll();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    setInterval(() => { }, 1000);
+});
+program
+    .command('sessions')
+    .description('List available tmux sessions')
+    .action(() => {
+    const sessions = listTmuxSessions();
+    if (sessions.length === 0) {
+        console.log('No tmux sessions found.');
+    }
+    else {
+        console.log('Available tmux sessions:');
+        sessions.forEach(s => console.log(`  - ${s}`));
+    }
+});
+program.parse();

package/dist/terminal.d.ts

@@ -0,0 +1,22 @@
+import { IPty } from 'node-pty';
+export interface TerminalSession {
+    id: string;
+    name: string;
+    command?: string;
+    pty?: IPty;
+    tmuxSession?: string;
+}
+export declare function setOutputHandler(handler: (sessionId: string, data: string) => void): void;
+export declare function setSessionsChangeHandler(handler: () => void): void;
+export declare function getSessionList(): {
+    id: string;
+    name: string;
+    command?: string;
+}[];
+export declare function listTmuxSessions(): string[];
+export declare function attachTmuxSession(sessionName: string): TerminalSession | null;
+export declare function spawnSession(command?: string): TerminalSession;
+export declare function writeToSession(sessionId: string, data: string): boolean;
+export declare function resizeSession(sessionId: string, cols: number, rows: number): boolean;
+export declare function attachSession(sessionId: string): boolean;
+export declare function cleanupAll(): void;

package/dist/terminal.js

@@ -0,0 +1,139 @@
+import { spawn as nodePtySpawn } from 'node-pty';
+import { execSync } from 'child_process';
+import { v4 as uuidv4 } from 'uuid';
+// Active sessions
+const sessions = new Map();
+// Callbacks
+let onOutput = null;
+let onSessionsChange = null;
+export function setOutputHandler(handler) {
+    onOutput = handler;
+}
+export function setSessionsChangeHandler(handler) {
+    onSessionsChange = handler;
+}
+export function getSessionList() {
+    return Array.from(sessions.values()).map(s => ({
+        id: s.id,
+        name: s.name,
+        command: s.command
+    }));
+}
+// List available tmux sessions
+export function listTmuxSessions() {
+    try {
+        const output = execSync('tmux list-sessions -F "#{session_name}"', { encoding: 'utf-8' });
+        return output.trim().split('\n').filter(s => s.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+// Attach to a tmux session
+export function attachTmuxSession(sessionName) {
+    try {
+        // Verify session exists
+        const sessions_list = listTmuxSessions();
+        if (!sessions_list.includes(sessionName)) {
+            console.error(`tmux session "${sessionName}" not found`);
+            return null;
+        }
+        const id = uuidv4();
+        const shell = process.env.SHELL || '/bin/bash';
+        // Spawn a PTY that attaches to the tmux session
+        const pty = nodePtySpawn(shell, ['-c', `tmux attach-session -t ${sessionName}`], {
+            name: 'xterm-256color',
+            cols: 80,
+            rows: 24,
+            cwd: process.env.HOME || '/',
+            env: process.env
+        });
+        const session = {
+            id,
+            name: `tmux: ${sessionName}`,
+            command: `tmux attach -t ${sessionName}`,
+            pty,
+            tmuxSession: sessionName
+        };
+        setupPtyHandlers(session);
+        sessions.set(id, session);
+        onSessionsChange?.();
+        console.log(`Attached to tmux session "${sessionName}" with id ${id}`);
+        return session;
+    }
+    catch (err) {
+        console.error('Failed to attach tmux session:', err);
+        return null;
+    }
+}
+// Spawn a new PTY session
+export function spawnSession(command) {
+    const id = uuidv4();
+    const shell = process.env.SHELL || '/bin/bash';
+    const cmd = command || shell;
+    const args = command ? ['-c', command] : [];
+    const pty = nodePtySpawn(command ? shell : shell, args, {
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+        cwd: process.env.HOME || '/',
+        env: process.env
+    });
+    const session = {
+        id,
+        name: command || shell,
+        command: cmd,
+        pty
+    };
+    setupPtyHandlers(session);
+    sessions.set(id, session);
+    onSessionsChange?.();
+    console.log(`Spawned session "${session.name}" with id ${id}`);
+    return session;
+}
+function setupPtyHandlers(session) {
+    if (!session.pty)
+        return;
+    session.pty.onData((data) => {
+        onOutput?.(session.id, data);
+    });
+    session.pty.onExit(({ exitCode }) => {
+        console.log(`Session "${session.name}" exited with code ${exitCode}`);
+        sessions.delete(session.id);
+        onSessionsChange?.();
+    });
+}
+// Write input to a session
+export function writeToSession(sessionId, data) {
+    const session = sessions.get(sessionId);
+    if (!session?.pty)
+        return false;
+    session.pty.write(data);
+    return true;
+}
+// Resize a session
+export function resizeSession(sessionId, cols, rows) {
+    const session = sessions.get(sessionId);
+    if (!session?.pty)
+        return false;
+    try {
+        session.pty.resize(cols, rows);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Attach to session (no-op if already active, used when browser connects)
+export function attachSession(sessionId) {
+    return sessions.has(sessionId);
+}
+// Cleanup all sessions
+export function cleanupAll() {
+    for (const session of sessions.values()) {
+        if (session.pty) {
+            session.pty.kill();
+        }
+    }
+    sessions.clear();
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "remote-cli-agent",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "remote-cli": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "node-pty": "^1.0.0",
+    "uuid": "^9.0.0",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "description": "Remote CLI agent - access local terminal sessions from the browser",
+  "files": [
+    "dist/**/*"
+  ],
+  "keywords": [
+    "terminal",
+    "remote",
+    "tmux",
+    "pty",
+    "cli",
+    "websocket"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aim-research/remote-cli.git",
+    "directory": "agent"
+  }
+}