opencodespaces 0.1.0

package/dist/commands/sync.js

@@ -0,0 +1,353 @@
+/**
+ * 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 { execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { isLoggedIn } from '../lib/auth.js';
+import { api } from '../lib/api.js';
+import { getIgnoreList, saveSessionKey, deleteSessionKey, } from '../lib/config.js';
+import { logger } from '../utils/logger.js';
+// SSH config directory
+const SSH_CONFIG_DIR = path.join(os.homedir(), '.ssh', 'config.d');
+export function syncCommand(program) {
+    const sync = program.command('sync').description('Sync local directory with session');
+    // Interactive mode (default)
+    sync.action(async () => {
+        await interactiveSync();
+    });
+    // Start sync
+    sync
+        .command('start <sessionId>')
+        .description('Start syncing with a session')
+        .option('-d, --dir <path>', 'Local directory', '.')
+        .action(async (sessionId, options) => {
+        await startSync(sessionId, options.dir);
+    });
+    // Stop sync
+    sync
+        .command('stop [sessionId]')
+        .description('Stop syncing (all or specific session)')
+        .action(async (sessionId) => {
+        await stopSync(sessionId);
+    });
+    // Status
+    sync
+        .command('status')
+        .description('Show sync status')
+        .action(async () => {
+        await showSyncStatus();
+    });
+}
+/**
+ * Interactive sync setup
+ */
+async function interactiveSync() {
+    if (!isLoggedIn()) {
+        logger.error('Not logged in. Run: opencodespaces login');
+        process.exit(1);
+    }
+    checkDependencies();
+    const spinner = ora('Loading sessions...').start();
+    try {
+        const results = await api.listAllSessions();
+        spinner.stop();
+        if (results.length === 0) {
+            logger.warn('No sessions found');
+            logger.dim('Make sure you have running containers with initialized sessions.');
+            process.exit(1);
+        }
+        // Build choices for inquirer
+        const choices = results.map(({ workspace, space, session }) => ({
+            name: `${session.name} (${workspace.name}/${space.name}) - ${session.sessionStatus}`,
+            value: session.id,
+            short: session.name,
+        }));
+        // Session selection
+        const { selectedSession } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedSession',
+                message: 'Select a session to sync:',
+                choices,
+            },
+        ]);
+        // Find selected session info
+        const selected = results.find((r) => r.session.id === selectedSession);
+        const suggestedDir = `./${selected?.session.name || 'project'}`;
+        // Local directory selection
+        const { localDir } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'localDir',
+                message: 'Local directory:',
+                default: suggestedDir,
+            },
+        ]);
+        // Start sync
+        await startSync(selectedSession, localDir);
+    }
+    catch (error) {
+        spinner.fail(`Failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Start sync with a session
+ */
+async function startSync(sessionId, localDir) {
+    if (!isLoggedIn()) {
+        logger.error('Not logged in. Run: opencodespaces login');
+        process.exit(1);
+    }
+    checkDependencies();
+    const spinner = ora('Initializing sync...').start();
+    try {
+        // Initialize sync on server (get SSH credentials)
+        const syncInfo = await api.initSync(sessionId);
+        // Save private key
+        const keyPath = saveSessionKey(sessionId, syncInfo.privateKey);
+        spinner.text = 'Configuring SSH...';
+        // Create SSH config
+        await createSshConfig(sessionId, keyPath, syncInfo.user);
+        // Resolve and create local directory
+        const localPath = path.resolve(localDir);
+        if (!fs.existsSync(localPath)) {
+            fs.mkdirSync(localPath, { recursive: true });
+        }
+        spinner.text = 'Starting Mutagen sync...';
+        // Build Mutagen command
+        const hostAlias = `ocs-${sessionId}`;
+        const remotePath = syncInfo.remotePath;
+        const ignores = getIgnoreList();
+        const ignoreArgs = ignores.flatMap((i) => ['--ignore', i]);
+        // Create Mutagen sync session
+        const mutagenArgs = [
+            'sync',
+            'create',
+            localPath,
+            `${hostAlias}:${remotePath}`,
+            '--name',
+            `opencodespaces-${sessionId}`,
+            '--sync-mode',
+            'two-way-resolved',
+            ...ignoreArgs,
+        ];
+        execSync(`mutagen ${mutagenArgs.join(' ')}`, { stdio: 'pipe' });
+        spinner.succeed(`Syncing ${localPath} ↔ ${hostAlias}:${remotePath}`);
+        logger.log('');
+        logger.warn('Note: node_modules and other large directories are excluded by default.');
+        logger.dim('Run "npm install" in both local and remote if needed.');
+        logger.log('');
+        logger.info('Watching for changes... (Ctrl+C to stop)');
+        logger.log('');
+        // Setup cleanup handler
+        const cleanup = async () => {
+            logger.log('');
+            logger.info('Stopping sync...');
+            try {
+                await stopSyncSession(sessionId);
+                logger.success('Disconnected');
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        // Start Mutagen monitor (shows live sync status)
+        const monitor = spawn('mutagen', ['sync', 'monitor', `opencodespaces-${sessionId}`], {
+            stdio: 'inherit',
+        });
+        monitor.on('close', () => {
+            // Monitor closed, cleanup
+            cleanup();
+        });
+    }
+    catch (error) {
+        spinner.fail(`Failed to start sync: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Stop sync for a session or all sessions
+ */
+async function stopSync(sessionId) {
+    if (sessionId) {
+        const spinner = ora(`Stopping sync for session ${sessionId}...`).start();
+        try {
+            await stopSyncSession(sessionId);
+            spinner.succeed('Sync stopped');
+        }
+        catch (error) {
+            spinner.fail(`Failed: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Stop all OpenCodeSpaces syncs
+        const spinner = ora('Stopping all syncs...').start();
+        try {
+            // List all Mutagen sessions
+            const output = execSync('mutagen sync list', { encoding: 'utf-8' });
+            // Find OpenCodeSpaces sessions
+            const matches = output.match(/opencodespaces-[a-zA-Z0-9-]+/g) || [];
+            const uniqueSessions = [...new Set(matches)];
+            for (const name of uniqueSessions) {
+                try {
+                    execSync(`mutagen sync terminate ${name}`, { stdio: 'pipe' });
+                    const sessionId = name.replace('opencodespaces-', '');
+                    await api.stopSync(sessionId).catch(() => { }); // Ignore API errors
+                    deleteSessionKey(sessionId);
+                    deleteSshConfig(sessionId);
+                }
+                catch {
+                    // Ignore individual errors
+                }
+            }
+            spinner.succeed(`Stopped ${uniqueSessions.length} sync session(s)`);
+        }
+        catch (error) {
+            spinner.fail(`Failed: ${error.message}`);
+            process.exit(1);
+        }
+    }
+}
+/**
+ * Stop a specific sync session
+ */
+async function stopSyncSession(sessionId) {
+    // Terminate Mutagen session
+    try {
+        execSync(`mutagen sync terminate opencodespaces-${sessionId}`, { stdio: 'pipe' });
+    }
+    catch {
+        // Session might not exist
+    }
+    // Notify API (remove SSH key from container)
+    try {
+        await api.stopSync(sessionId);
+    }
+    catch {
+        // Ignore API errors
+    }
+    // Cleanup local files
+    deleteSessionKey(sessionId);
+    deleteSshConfig(sessionId);
+}
+/**
+ * Show sync status
+ */
+async function showSyncStatus() {
+    try {
+        const output = execSync('mutagen sync list', { encoding: 'utf-8' });
+        // Parse Mutagen output
+        const sessions = output
+            .split('\n')
+            .filter((line) => line.includes('opencodespaces-'));
+        if (sessions.length === 0) {
+            logger.info('No active sync sessions');
+            return;
+        }
+        logger.log('');
+        logger.bold('Active Sync Sessions');
+        logger.log('');
+        // Show detailed status
+        execSync('mutagen sync list', { stdio: 'inherit' });
+    }
+    catch {
+        logger.info('No active sync sessions');
+    }
+}
+/**
+ * Create SSH config for session
+ */
+async function createSshConfig(sessionId, keyPath, user) {
+    // Ensure SSH config directory exists
+    if (!fs.existsSync(SSH_CONFIG_DIR)) {
+        fs.mkdirSync(SSH_CONFIG_DIR, { recursive: true });
+    }
+    // Get CLI path
+    const cliPath = process.argv[1];
+    const hostAlias = `ocs-${sessionId}`;
+    const sshConfig = `# OpenCodeSpaces session: ${sessionId}
+Host ${hostAlias}
+  User ${user}
+  IdentityFile ${keyPath}
+  IdentitiesOnly yes
+  StrictHostKeyChecking no
+  UserKnownHostsFile /dev/null
+  LogLevel ERROR
+  ProxyCommand ${cliPath} ssh ${sessionId} --stdio
+`;
+    const configPath = path.join(SSH_CONFIG_DIR, `opencodespaces-${sessionId}`);
+    fs.writeFileSync(configPath, sshConfig, { mode: 0o600 });
+    // Ensure main SSH config includes our config.d directory
+    await ensureSshConfigIncludes();
+}
+/**
+ * Delete SSH config for session
+ */
+function deleteSshConfig(sessionId) {
+    const configPath = path.join(SSH_CONFIG_DIR, `opencodespaces-${sessionId}`);
+    if (fs.existsSync(configPath)) {
+        fs.unlinkSync(configPath);
+    }
+}
+/**
+ * Ensure main SSH config includes our config.d directory
+ */
+async function ensureSshConfigIncludes() {
+    const sshConfigPath = path.join(os.homedir(), '.ssh', 'config');
+    const includeDir = SSH_CONFIG_DIR;
+    // Create .ssh directory if needed
+    const sshDir = path.dirname(sshConfigPath);
+    if (!fs.existsSync(sshDir)) {
+        fs.mkdirSync(sshDir, { mode: 0o700 });
+    }
+    // Check if config exists and includes our directory
+    if (fs.existsSync(sshConfigPath)) {
+        const content = fs.readFileSync(sshConfigPath, 'utf-8');
+        if (content.includes(includeDir) || content.includes('config.d/*')) {
+            return; // Already configured
+        }
+        // Prepend include directive
+        const newContent = `# Include OpenCodeSpaces configs\nInclude ${includeDir}/*\n\n${content}`;
+        fs.writeFileSync(sshConfigPath, newContent, { mode: 0o600 });
+    }
+    else {
+        // Create new config with include
+        const newContent = `# Include OpenCodeSpaces configs\nInclude ${includeDir}/*\n`;
+        fs.writeFileSync(sshConfigPath, newContent, { mode: 0o600 });
+    }
+}
+/**
+ * Check if Mutagen is installed
+ */
+function checkDependencies() {
+    try {
+        execSync('mutagen version', { stdio: 'pipe' });
+    }
+    catch {
+        logger.error('Mutagen not found. Please install it:');
+        logger.log('');
+        logger.log('  macOS:   brew install mutagen-io/mutagen/mutagen');
+        logger.log('  Linux:   Download from https://mutagen.io/documentation/introduction/installation');
+        logger.log('  Windows: Download from https://mutagen.io/documentation/introduction/installation');
+        logger.log('');
+        process.exit(1);
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whoami Command
+ *
+ * Shows current logged-in user info.
+ */
+import { Command } from 'commander';
+export declare function whoamiCommand(program: Command): void;

package/dist/commands/whoami.js

@@ -0,0 +1,50 @@
+/**
+ * Whoami Command
+ *
+ * Shows current logged-in user info.
+ */
+import { isLoggedIn, getCredentials } from '../lib/auth.js';
+import { api } from '../lib/api.js';
+import { logger } from '../utils/logger.js';
+import { getServerUrl } from '../lib/config.js';
+export function whoamiCommand(program) {
+    program
+        .command('whoami')
+        .description('Show current user info')
+        .action(async () => {
+        if (!isLoggedIn()) {
+            logger.error('Not logged in. Run: opencodespaces login');
+            process.exit(1);
+        }
+        const creds = getCredentials();
+        const serverUrl = getServerUrl();
+        try {
+            // Verify token is still valid by calling API
+            const user = await api.me();
+            logger.log('');
+            logger.bold('Current User');
+            logger.log(`  Email: ${user.email}`);
+            logger.log(`  Name:  ${user.name}`);
+            logger.log(`  Role:  ${user.role}`);
+            logger.log(`  Server: ${serverUrl}`);
+            logger.log('');
+        }
+        catch (error) {
+            // Token might be invalid, show cached info with warning
+            if (creds?.email) {
+                logger.warn('Session may have expired. Run: opencodespaces login');
+                logger.log('');
+                logger.dim('Cached info:');
+                logger.log(`  Email: ${creds.email}`);
+                if (creds.name)
+                    logger.log(`  Name:  ${creds.name}`);
+                logger.log(`  Server: ${serverUrl}`);
+                logger.log('');
+            }
+            else {
+                logger.error('Session expired. Run: opencodespaces login');
+                process.exit(1);
+            }
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * OpenCodeSpaces CLI
+ *
+ * Connect your local IDE to cloud sessions for bidirectional file sync.
+ *
+ * Usage:
+ *   opencodespaces login [server-url]   - Authenticate with browser OAuth
+ *   opencodespaces logout               - Remove stored credentials
+ *   opencodespaces whoami               - Show current user
+ *   opencodespaces sessions [list]      - List available sessions
+ *   opencodespaces sync                 - Interactive sync setup
+ *   opencodespaces sync start <id>      - Start syncing with a session
+ *   opencodespaces sync stop [id]       - Stop syncing
+ *   opencodespaces sync status          - Show sync status
+ *   opencodespaces ssh <id> [--stdio]   - SSH tunnel to session
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * OpenCodeSpaces CLI
+ *
+ * Connect your local IDE to cloud sessions for bidirectional file sync.
+ *
+ * Usage:
+ *   opencodespaces login [server-url]   - Authenticate with browser OAuth
+ *   opencodespaces logout               - Remove stored credentials
+ *   opencodespaces whoami               - Show current user
+ *   opencodespaces sessions [list]      - List available sessions
+ *   opencodespaces sync                 - Interactive sync setup
+ *   opencodespaces sync start <id>      - Start syncing with a session
+ *   opencodespaces sync stop [id]       - Stop syncing
+ *   opencodespaces sync status          - Show sync status
+ *   opencodespaces ssh <id> [--stdio]   - SSH tunnel to session
+ */
+import { Command } from 'commander';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { whoamiCommand } from './commands/whoami.js';
+import { sessionsCommand } from './commands/sessions.js';
+import { syncCommand } from './commands/sync.js';
+import { sshCommand } from './commands/ssh.js';
+import { version } from './lib/version.js';
+const program = new Command();
+program
+    .name('opencodespaces')
+    .description('Connect your local IDE to OpenCodeSpaces cloud sessions')
+    .version(version);
+// Register commands
+loginCommand(program);
+logoutCommand(program);
+whoamiCommand(program);
+sessionsCommand(program);
+syncCommand(program);
+sshCommand(program);
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,96 @@
+/**
+ * API Client for OpenCodeSpaces
+ */
+interface Session {
+    id: string;
+    name: string;
+    branchName: string;
+    workDir: string;
+    sessionStatus: string;
+    spaceId: string;
+    createdAt: string;
+    lastActive: string;
+}
+interface Workspace {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface Space {
+    id: string;
+    name: string;
+    workspaceId: string;
+    container?: {
+        id: string;
+        status: string;
+        mappedPort: number | null;
+    };
+}
+interface SyncInitResponse {
+    privateKey: string;
+    wsUrl: string;
+    remotePath: string;
+    user: string;
+    sshPort: number;
+    expiresAt: string;
+}
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+}
+declare class ApiError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+/**
+ * API client methods
+ */
+export declare const api: {
+    /**
+     * Get current user info
+     */
+    me(): Promise<User>;
+    /**
+     * List workspaces
+     */
+    listWorkspaces(): Promise<Workspace[]>;
+    /**
+     * List spaces in a workspace
+     */
+    listSpaces(workspaceId: string): Promise<Space[]>;
+    /**
+     * List sessions for a space
+     */
+    listSessionsForSpace(spaceId: string): Promise<Session[]>;
+    /**
+     * List all sessions the user has access to
+     */
+    listAllSessions(): Promise<{
+        workspace: Workspace;
+        space: Space;
+        session: Session;
+    }[]>;
+    /**
+     * Get a specific session
+     */
+    getSession(sessionId: string): Promise<Session>;
+    /**
+     * Initialize sync for a session
+     */
+    initSync(sessionId: string): Promise<SyncInitResponse>;
+    /**
+     * Stop sync for a session
+     */
+    stopSync(sessionId: string): Promise<void>;
+    /**
+     * Get sync status for a session
+     */
+    getSyncStatus(sessionId: string): Promise<{
+        active: boolean;
+        expiresAt: string | null;
+    }>;
+};
+export { ApiError };
+export type { Session, Workspace, Space, SyncInitResponse, User };

package/dist/lib/api.js

@@ -0,0 +1,130 @@
+/**
+ * API Client for OpenCodeSpaces
+ */
+import { loadCredentials, getServerUrl } from './config.js';
+class ApiError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Make an API request
+ */
+async function request(endpoint, options = {}) {
+    const { method = 'GET', body, requireAuth = true } = options;
+    const creds = loadCredentials();
+    const serverUrl = getServerUrl();
+    if (requireAuth && !creds?.token) {
+        throw new ApiError(401, 'Not logged in. Run: opencodespaces login');
+    }
+    const url = `${serverUrl}/api${endpoint}`;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (creds?.token) {
+        headers['Authorization'] = `Bearer ${creds.token}`;
+    }
+    const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const json = (await response.json());
+    if (!response.ok || !json.success) {
+        throw new ApiError(response.status, json.error || `Request failed with status ${response.status}`);
+    }
+    return json.data;
+}
+/**
+ * API client methods
+ */
+export const api = {
+    /**
+     * Get current user info
+     */
+    async me() {
+        return request('/auth/me');
+    },
+    /**
+     * List workspaces
+     */
+    async listWorkspaces() {
+        return request('/workspaces');
+    },
+    /**
+     * List spaces in a workspace
+     */
+    async listSpaces(workspaceId) {
+        return request(`/workspaces/${workspaceId}/spaces`);
+    },
+    /**
+     * List sessions for a space
+     */
+    async listSessionsForSpace(spaceId) {
+        return request(`/sessions/space/${spaceId}`);
+    },
+    /**
+     * List all sessions the user has access to
+     */
+    async listAllSessions() {
+        const workspaces = await this.listWorkspaces();
+        const results = [];
+        for (const workspace of workspaces) {
+            try {
+                const spaces = await this.listSpaces(workspace.id);
+                for (const space of spaces) {
+                    // Check container.status instead of space.status
+                    if (space.container?.status === 'RUNNING') {
+                        try {
+                            const sessions = await this.listSessionsForSpace(space.id);
+                            for (const session of sessions) {
+                                if (session.sessionStatus === 'READY') {
+                                    results.push({ workspace, space, session });
+                                }
+                            }
+                        }
+                        catch {
+                            // Skip spaces we can't access
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip workspaces we can't access
+            }
+        }
+        return results;
+    },
+    /**
+     * Get a specific session
+     */
+    async getSession(sessionId) {
+        return request(`/sessions/${sessionId}`);
+    },
+    /**
+     * Initialize sync for a session
+     */
+    async initSync(sessionId) {
+        return request(`/sessions/${sessionId}/sync/init`, {
+            method: 'POST',
+        });
+    },
+    /**
+     * Stop sync for a session
+     */
+    async stopSync(sessionId) {
+        await request(`/sessions/${sessionId}/sync`, {
+            method: 'DELETE',
+        });
+    },
+    /**
+     * Get sync status for a session
+     */
+    async getSyncStatus(sessionId) {
+        return request(`/sessions/${sessionId}/sync`);
+    },
+};
+export { ApiError };