opencodespaces 0.1.0

package/README.md

@@ -0,0 +1,104 @@
+# OpenCodeSpaces CLI
+
+Connect your local IDE (VSCode, JetBrains, Neovim, etc.) to [OpenCodeSpaces](https://github.com/techdivision-rnd/opencodespaces) cloud development sessions.
+
+## Features
+
+- **Bidirectional file sync** - Changes sync in real-time between local and cloud
+- **Works with any IDE** - VSCode, JetBrains, Neovim, Sublime, and more
+- **SSH tunneling** - Secure WebSocket connection, no exposed ports required
+- **Interactive session selection** - Easy session picker or direct ID usage
+
+## Prerequisites
+
+Install [Mutagen](https://mutagen.io) for file synchronization:
+
+```bash
+# macOS
+brew install mutagen-io/mutagen/mutagen
+
+# Linux/Windows
+# Download from https://mutagen.io/documentation/introduction/installation
+```
+
+## Installation
+
+```bash
+npm install -g opencodespaces
+```
+
+## Quick Start
+
+```bash
+# 1. Login to your OpenCodeSpaces server
+opencodespaces login https://your-server.com
+
+# 2. Start syncing (interactive mode)
+opencodespaces sync
+
+# 3. Open the local directory in your favorite IDE
+```
+
+## Commands
+
+### Authentication
+
+| Command | Description |
+|---------|-------------|
+| `opencodespaces login [server]` | Authenticate via browser OAuth |
+| `opencodespaces login [server] --save` | Login and save server as default |
+| `opencodespaces logout` | Remove stored credentials |
+| `opencodespaces whoami` | Show current user and server |
+
+### Sessions
+
+| Command | Description |
+|---------|-------------|
+| `opencodespaces sessions` | List available sessions |
+
+### Sync
+
+| Command | Description |
+|---------|-------------|
+| `opencodespaces sync` | Interactive session selection and sync |
+| `opencodespaces sync start <id> [-d path]` | Start syncing with a specific session |
+| `opencodespaces sync stop [id]` | Stop syncing (all or specific session) |
+| `opencodespaces sync status` | Show current sync status |
+
+### SSH
+
+| Command | Description |
+|---------|-------------|
+| `opencodespaces ssh <id>` | Open SSH shell to session |
+| `opencodespaces ssh <id> --stdio` | STDIO mode for ProxyCommand |
+
+## Excluded Files
+
+By default, these patterns are excluded from sync:
+
+```
+node_modules/  .git/  .DS_Store  *.log  dist/  build/
+coverage/  .next/  __pycache__/  venv/  .venv/  .turbo/  .cache/
+```
+
+Run `npm install` separately on both local and remote environments.
+
+## Configuration
+
+Configuration files are stored in `~/.opencodespaces/`:
+
+| File | Purpose |
+|------|---------|
+| `config.json` | Server URL, custom ignores |
+| `credentials.json` | Auth token (auto-managed) |
+| `keys/` | Temporary SSH keys |
+
+## Documentation
+
+For full documentation, see:
+- [Local IDE Sync Guide](https://github.com/techdivision-rnd/opencodespaces/blob/master/docs/LOCAL_IDE_SYNC.md)
+- [OpenCodeSpaces Documentation](https://github.com/techdivision-rnd/opencodespaces)
+
+## License
+
+MIT

package/dist/commands/login.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Login Command
+ *
+ * Authenticates with OpenCodeSpaces via browser OAuth.
+ */
+import { Command } from 'commander';
+export declare function loginCommand(program: Command): void;

package/dist/commands/login.js

@@ -0,0 +1,42 @@
+/**
+ * Login Command
+ *
+ * Authenticates with OpenCodeSpaces via browser OAuth.
+ */
+import ora from 'ora';
+import { browserLogin } from '../lib/auth.js';
+import { logger } from '../utils/logger.js';
+import { getServerUrl, saveConfig, loadConfig } from '../lib/config.js';
+export function loginCommand(program) {
+    program
+        .command('login [server]')
+        .description('Authenticate with OpenCodeSpaces via browser')
+        .option('-s, --save', 'Save server URL as default for future logins')
+        .action(async (server, options) => {
+        const serverUrl = getServerUrl(server);
+        logger.info(`Logging in to ${serverUrl}`);
+        logger.dim('Opening browser for authentication...');
+        const spinner = ora('Waiting for authentication...').start();
+        try {
+            const result = await browserLogin(serverUrl);
+            if (result.success) {
+                spinner.succeed(`Logged in as ${result.email || result.name || 'user'}`);
+                // Save server as default if requested
+                if (options?.save && server) {
+                    const config = loadConfig();
+                    config.server = serverUrl;
+                    saveConfig(config);
+                    logger.dim(`Server saved as default: ${serverUrl}`);
+                }
+            }
+            else {
+                spinner.fail(`Login failed: ${result.error}`);
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            spinner.fail(`Login failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Logout Command
+ *
+ * Removes stored credentials.
+ */
+import { Command } from 'commander';
+export declare function logoutCommand(program: Command): void;

package/dist/commands/logout.js

@@ -0,0 +1,20 @@
+/**
+ * Logout Command
+ *
+ * Removes stored credentials.
+ */
+import { logout, isLoggedIn } from '../lib/auth.js';
+import { logger } from '../utils/logger.js';
+export function logoutCommand(program) {
+    program
+        .command('logout')
+        .description('Remove stored credentials')
+        .action(() => {
+        if (!isLoggedIn()) {
+            logger.warn('Not logged in');
+            return;
+        }
+        logout();
+        logger.success('Logged out successfully');
+    });
+}

package/dist/commands/sessions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sessions Command
+ *
+ * List available sessions with optional interactive selection.
+ */
+import { Command } from 'commander';
+export declare function sessionsCommand(program: Command): void;

package/dist/commands/sessions.js

@@ -0,0 +1,76 @@
+/**
+ * Sessions Command
+ *
+ * List available sessions with optional interactive selection.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { isLoggedIn } from '../lib/auth.js';
+import { api } from '../lib/api.js';
+import { logger } from '../utils/logger.js';
+export function sessionsCommand(program) {
+    const sessions = program
+        .command('sessions')
+        .description('List and manage sessions');
+    sessions
+        .command('list')
+        .description('List all available sessions')
+        .option('-w, --workspace <id>', 'Filter by workspace ID')
+        .action(async (options) => {
+        if (!isLoggedIn()) {
+            logger.error('Not logged in. Run: opencodespaces login');
+            process.exit(1);
+        }
+        const spinner = ora('Loading sessions...').start();
+        try {
+            const results = await api.listAllSessions();
+            // Filter by workspace if specified
+            const filtered = options.workspace
+                ? results.filter((r) => r.workspace.id === options.workspace)
+                : results;
+            spinner.stop();
+            if (filtered.length === 0) {
+                logger.warn('No sessions found');
+                logger.dim('Make sure you have running containers with initialized sessions.');
+                return;
+            }
+            logger.log('');
+            logger.bold('Available Sessions');
+            logger.log('');
+            // Group by workspace
+            const byWorkspace = new Map();
+            for (const item of filtered) {
+                const key = item.workspace.id;
+                if (!byWorkspace.has(key)) {
+                    byWorkspace.set(key, []);
+                }
+                byWorkspace.get(key).push(item);
+            }
+            for (const [, items] of byWorkspace) {
+                const ws = items[0].workspace;
+                logger.log(chalk.cyan(`  ${ws.name}`));
+                for (const { space, session } of items) {
+                    const statusIcon = session.sessionStatus === 'READY'
+                        ? chalk.green('●')
+                        : chalk.yellow('○');
+                    logger.log(`    ${statusIcon} ${session.name} ${chalk.dim(`(${session.id.slice(0, 8)}...)`)}`);
+                    logger.dim(`       Space: ${space.name} | Branch: ${session.branchName || 'none'}`);
+                }
+                logger.log('');
+            }
+            logger.dim(`Found ${filtered.length} session(s)`);
+            logger.log('');
+        }
+        catch (error) {
+            spinner.fail(`Failed to load sessions: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    // Default action (list)
+    sessions.action(async () => {
+        // Run list command by default
+        await sessions.commands
+            .find((c) => c.name() === 'list')
+            ?.parseAsync([], { from: 'user' });
+    });
+}

package/dist/commands/ssh.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SSH Tunnel Command
+ *
+ * Provides SSH tunnel to sessions via WebSocket.
+ * Used as ProxyCommand for SSH/Mutagen.
+ *
+ * Usage:
+ *   opencodespaces ssh <sessionId> --stdio    # For ProxyCommand
+ *   opencodespaces ssh <sessionId>            # Interactive SSH shell
+ */
+import { Command } from 'commander';
+export declare function sshCommand(program: Command): void;

package/dist/commands/ssh.js

@@ -0,0 +1,141 @@
+/**
+ * SSH Tunnel Command
+ *
+ * Provides SSH tunnel to sessions via WebSocket.
+ * Used as ProxyCommand for SSH/Mutagen.
+ *
+ * Usage:
+ *   opencodespaces ssh <sessionId> --stdio    # For ProxyCommand
+ *   opencodespaces ssh <sessionId>            # Interactive SSH shell
+ */
+import { WebSocket } from 'ws';
+import { isLoggedIn, getCredentials } from '../lib/auth.js';
+import { getServerUrl } from '../lib/config.js';
+import { logger } from '../utils/logger.js';
+export function sshCommand(program) {
+    program
+        .command('ssh <sessionId>')
+        .description('SSH tunnel to a session')
+        .option('--stdio', 'STDIO mode for SSH ProxyCommand (required for Mutagen)')
+        .action(async (sessionId, options) => {
+        if (!isLoggedIn()) {
+            // Write to stderr in stdio mode to not interfere with SSH protocol
+            if (options.stdio) {
+                process.stderr.write('Not logged in. Run: opencodespaces login\n');
+            }
+            else {
+                logger.error('Not logged in. Run: opencodespaces login');
+            }
+            process.exit(1);
+        }
+        const creds = getCredentials();
+        if (!creds?.token) {
+            if (options.stdio) {
+                process.stderr.write('No credentials found. Run: opencodespaces login\n');
+            }
+            else {
+                logger.error('No credentials found. Run: opencodespaces login');
+            }
+            process.exit(1);
+        }
+        const serverUrl = getServerUrl();
+        if (options.stdio) {
+            // STDIO mode: bidirectional piping for SSH ProxyCommand
+            await runStdioTunnel(serverUrl, sessionId, creds.token);
+        }
+        else {
+            // Interactive mode: spawn SSH command using this CLI as ProxyCommand
+            await runInteractiveSsh(sessionId);
+        }
+    });
+}
+/**
+ * Run tunnel in STDIO mode (for SSH ProxyCommand)
+ *
+ * This bridges STDIN/STDOUT to the WebSocket, allowing SSH to use
+ * this CLI as a transport layer.
+ */
+async function runStdioTunnel(serverUrl, sessionId, token) {
+    // Build WebSocket URL
+    const wsProtocol = serverUrl.startsWith('https://') ? 'wss://' : 'ws://';
+    const wsHost = serverUrl.replace(/^https?:\/\//, '');
+    const wsUrl = `${wsProtocol}${wsHost}/api/sessions/${sessionId}/ssh?token=${encodeURIComponent(token)}`;
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(wsUrl);
+        // Set binary type for raw SSH data
+        ws.binaryType = 'nodebuffer';
+        ws.on('open', () => {
+            // Process is now in raw mode - pipe everything through
+            // STDIN -> WebSocket
+            process.stdin.on('data', (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data);
+                }
+            });
+            process.stdin.on('end', () => {
+                ws.close();
+            });
+            // Handle process termination
+            process.stdin.resume();
+        });
+        // WebSocket -> STDOUT
+        ws.on('message', (data) => {
+            if (Buffer.isBuffer(data)) {
+                process.stdout.write(data);
+            }
+            else {
+                process.stdout.write(data);
+            }
+        });
+        ws.on('error', (err) => {
+            process.stderr.write(`WebSocket error: ${err.message}\n`);
+            reject(err);
+        });
+        ws.on('close', (code, reason) => {
+            if (code !== 1000 && code !== 1001) {
+                process.stderr.write(`Connection closed: ${code} ${reason}\n`);
+            }
+            resolve();
+        });
+        // Handle process signals
+        const cleanup = () => {
+            ws.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        process.on('SIGHUP', cleanup);
+    });
+}
+/**
+ * Run interactive SSH session
+ *
+ * Spawns SSH command using this CLI as ProxyCommand.
+ */
+async function runInteractiveSsh(sessionId) {
+    const { execSync } = await import('child_process');
+    // Get the path to this CLI executable
+    const cliPath = process.argv[1];
+    // Build SSH command with our CLI as ProxyCommand
+    const sshArgs = [
+        '-o', `ProxyCommand="${cliPath} ssh ${sessionId} --stdio"`,
+        '-o', 'StrictHostKeyChecking=no',
+        '-o', 'UserKnownHostsFile=/dev/null',
+        'opencode@localhost', // User and host (host is ignored due to ProxyCommand)
+    ];
+    logger.info(`Connecting to session ${sessionId}...`);
+    logger.dim('Use Ctrl+D or type "exit" to disconnect');
+    logger.log('');
+    try {
+        execSync(`ssh ${sshArgs.join(' ')}`, {
+            stdio: 'inherit',
+        });
+    }
+    catch (error) {
+        // SSH returns non-zero on normal disconnect, ignore
+        const err = error;
+        if (err.status !== 255) {
+            throw error;
+        }
+    }
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Sync Command
+ *
+ * Bidirectional file sync between local directory and cloud session.
+ * Uses Mutagen for reliable, real-time synchronization.
+ *
+ * Usage:
+ *   opencodespaces sync                     # Interactive session selection
+ *   opencodespaces sync start <id> [-d .]   # Start sync with session
+ *   opencodespaces sync stop [id]           # Stop sync
+ *   opencodespaces sync status              # Show sync status
+ */
+import { Command } from 'commander';
+export declare function syncCommand(program: Command): void;