recoder-code 2.5.2 → 2.5.3

package/dist/src/commands/web/pull.js

@@ -0,0 +1,203 @@
+/**
+ * 'recoder web pull' command
+ * Pull web project files to local directory
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { RecoderWebService } from '../../services/RecoderWebService.js';
+import { RecoderAuthService } from '../../services/RecoderAuthService.js';
+const DOCKER_BACKEND_URL = process.env['RECODER_DOCKER_URL'] || 'https://docker.recoder.xyz';
+export const pullCommand = {
+    command: 'pull [urlId]',
+    describe: 'Pull web project files to local directory',
+    builder: (yargs) => yargs
+        .positional('urlId', {
+        type: 'string',
+        description: 'Project URL ID (optional, will read from .recoder-web if present)',
+    })
+        .option('directory', {
+        type: 'string',
+        alias: 'd',
+        description: 'Directory to pull to (defaults to current directory)',
+        default: process.cwd(),
+    })
+        .option('dry-run', {
+        type: 'boolean',
+        description: 'Show what would be pulled without actually pulling',
+        default: false,
+    })
+        .option('force', {
+        type: 'boolean',
+        alias: 'f',
+        description: 'Overwrite local files without prompting',
+        default: false,
+    }),
+    handler: async (argv) => {
+        const webService = new RecoderWebService();
+        const authService = new RecoderAuthService();
+        try {
+            // Check authentication
+            const isAuth = await authService.isAuthenticated();
+            if (!isAuth) {
+                console.error('Not authenticated');
+                console.log('Run: recoder auth login');
+                process.exit(1);
+            }
+            const targetDir = path.resolve(argv.directory || process.cwd());
+            let urlId = argv.urlId;
+            // Try to read .recoder-web metadata if no urlId provided
+            if (!urlId) {
+                try {
+                    const metadataPath = path.join(targetDir, '.recoder-web');
+                    const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+                    urlId = metadata.urlId || metadata.projectId;
+                    console.log(`Found project ID from .recoder-web: ${urlId}`);
+                }
+                catch {
+                    console.error('No project ID provided and no .recoder-web file found');
+                    console.log('Usage: recoder web pull <urlId>');
+                    console.log('   Or run from a linked directory');
+                    process.exit(1);
+                }
+            }
+            console.log(`Pulling project: ${urlId}`);
+            console.log(`Local directory: ${targetDir}\n`);
+            // Get token for backend request
+            const token = await authService.getAccessToken();
+            if (!token) {
+                console.error('Failed to get access token');
+                process.exit(1);
+            }
+            // Try to pull from docker backend first (for running containers)
+            let remoteFiles = {};
+            let pullSource = 'web';
+            try {
+                console.log('Checking docker backend for running container...');
+                const response = await fetch(`${DOCKER_BACKEND_URL}/api/sync/${urlId}/pull`, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                    },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.success && data.files) {
+                        remoteFiles = data.files;
+                        pullSource = 'docker';
+                        console.log(`Found running container with ${data.fileCount} files`);
+                    }
+                }
+            }
+            catch {
+                // Docker backend not available, fall back to web API
+            }
+            // Fall back to web API if docker backend didn't work
+            if (Object.keys(remoteFiles).length === 0) {
+                console.log('Fetching from web API...');
+                try {
+                    const project = await webService.getProject(urlId);
+                    remoteFiles = project.fileSnapshot || {};
+                    console.log(`Found ${Object.keys(remoteFiles).length} files in web snapshot`);
+                }
+                catch (error) {
+                    console.error(`Failed to fetch project: ${error.message}`);
+                    process.exit(1);
+                }
+            }
+            if (Object.keys(remoteFiles).length === 0) {
+                console.log('\nNo files found in project');
+                return;
+            }
+            // Scan local files
+            console.log('\nScanning local directory...');
+            const localFiles = await webService.scanDirectory(targetDir);
+            // Detect changes (from remote perspective - what needs to come down)
+            const changes = await webService.detectChanges(localFiles, remoteFiles);
+            // Files to download: files in remote but not in local, or modified
+            const toDownload = [...changes.deleted, ...changes.modified];
+            // Files to add: files in local but not in remote - we don't touch these during pull
+            // Files to delete: none during pull unless --force
+            console.log('\nPull Analysis:');
+            console.log('-'.repeat(60));
+            if (changes.deleted.length > 0) {
+                console.log(`\nNew files to download (${changes.deleted.length}):`);
+                changes.deleted.slice(0, 15).forEach((file) => console.log(`  + ${file}`));
+                if (changes.deleted.length > 15) {
+                    console.log(`  ... and ${changes.deleted.length - 15} more`);
+                }
+            }
+            if (changes.modified.length > 0) {
+                console.log(`\nFiles to update (${changes.modified.length}):`);
+                changes.modified.slice(0, 15).forEach((file) => console.log(`  ~ ${file}`));
+                if (changes.modified.length > 15) {
+                    console.log(`  ... and ${changes.modified.length - 15} more`);
+                }
+            }
+            if (changes.added.length > 0) {
+                console.log(`\nLocal-only files (${changes.added.length}):`);
+                changes.added.slice(0, 10).forEach((file) => console.log(`  * ${file} (kept)`));
+                if (changes.added.length > 10) {
+                    console.log(`  ... and ${changes.added.length - 10} more`);
+                }
+            }
+            const hasChanges = toDownload.length > 0;
+            if (!hasChanges) {
+                console.log('\nLocal directory is up to date with remote!');
+                return;
+            }
+            // Dry run mode
+            if (argv['dry-run']) {
+                console.log('\nDry run mode - no files were downloaded');
+                console.log('Remove --dry-run to actually pull');
+                return;
+            }
+            // Check for conflicts if not forcing
+            if (!argv.force && changes.modified.length > 0) {
+                console.log('\nModified files will be overwritten.');
+                console.log('Use --force to proceed or --dry-run to see what would change.');
+                // In a real CLI we'd prompt, but for simplicity we'll just warn
+                console.log('\nProceeding with pull...');
+            }
+            // Download files
+            console.log('\nDownloading files...');
+            let downloaded = 0;
+            for (const filePath of toDownload) {
+                const content = remoteFiles[filePath];
+                if (content === undefined)
+                    continue;
+                const fullPath = path.join(targetDir, filePath);
+                const fileDir = path.dirname(fullPath);
+                try {
+                    await fs.mkdir(fileDir, { recursive: true });
+                    await fs.writeFile(fullPath, content, 'utf-8');
+                    downloaded++;
+                    console.log(`  Downloaded: ${filePath}`);
+                }
+                catch (error) {
+                    console.error(`  Failed: ${filePath} - ${error.message}`);
+                }
+            }
+            // Update metadata
+            const metadataFile = path.join(targetDir, '.recoder-web');
+            try {
+                let metadata = {};
+                try {
+                    metadata = JSON.parse(await fs.readFile(metadataFile, 'utf-8'));
+                }
+                catch { /* file doesn't exist */ }
+                metadata.urlId = urlId;
+                metadata.lastPull = new Date().toISOString();
+                metadata.pullSource = pullSource;
+                metadata.webUrl = webService.getProjectUrl(urlId);
+                await fs.writeFile(metadataFile, JSON.stringify(metadata, null, 2), 'utf-8');
+            }
+            catch { /* ignore metadata errors */ }
+            console.log(`\nPull complete!`);
+            console.log(`Downloaded ${downloaded} files from ${pullSource}`);
+            console.log(`View at: ${webService.getProjectUrl(urlId)}`);
+        }
+        catch (error) {
+            console.error(`${error.message}`);
+            process.exit(1);
+        }
+    },
+};

package/dist/src/commands/web/status.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 'recoder web status' command
+ * Show current project link and sync status
+ */
+import type { CommandModule } from 'yargs';
+interface StatusArgs {
+    directory?: string;
+}
+export declare const statusCommand: CommandModule<{}, StatusArgs>;
+export {};

package/dist/src/commands/web/status.js

@@ -0,0 +1,104 @@
+/**
+ * 'recoder web status' command
+ * Show current project link and sync status
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { RecoderAuthService } from '../../services/RecoderAuthService.js';
+import { RecoderWebService } from '../../services/RecoderWebService.js';
+export const statusCommand = {
+    command: 'status',
+    describe: 'Show project link and sync status',
+    builder: (yargs) => yargs.option('directory', {
+        type: 'string',
+        alias: 'd',
+        description: 'Directory to check (defaults to current directory)',
+        default: process.cwd(),
+    }),
+    handler: async (argv) => {
+        const authService = new RecoderAuthService();
+        const webService = new RecoderWebService();
+        try {
+            const targetDir = path.resolve(argv.directory || process.cwd());
+            // Check authentication
+            const isAuth = await authService.isAuthenticated();
+            const user = isAuth ? await authService.getUser() : null;
+            // Check for project link
+            let metadata = null;
+            try {
+                const metadataPath = path.join(targetDir, '.recoder-web');
+                metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+            }
+            catch { }
+            console.log('\n┌────────────────────────────────────────────────┐');
+            console.log('│  📊 Recoder Platform Status                    │');
+            console.log('├────────────────────────────────────────────────┤');
+            // Auth status
+            if (isAuth && user) {
+                console.log(`│  👤 Account: ${user.email.slice(0, 32).padEnd(32)}│`);
+                console.log(`│  📋 Plan: ${user.subscription_plan.toUpperCase().padEnd(35)}│`);
+            }
+            else {
+                console.log('│  👤 Account: Not logged in                     │');
+                console.log('│  💡 Run: recoder auth login                    │');
+            }
+            console.log('├────────────────────────────────────────────────┤');
+            // Project link status
+            if (metadata?.urlId || metadata?.projectId) {
+                const projectId = metadata.urlId || metadata.projectId;
+                console.log(`│  🔗 Linked: Yes                                │`);
+                console.log(`│  📁 Project: ${projectId.slice(0, 32).padEnd(32)}│`);
+                if (metadata.linkedAt) {
+                    const linkedDate = new Date(metadata.linkedAt).toLocaleDateString();
+                    console.log(`│  📅 Linked: ${linkedDate.padEnd(33)}│`);
+                }
+                if (metadata.lastSync) {
+                    const syncDate = new Date(metadata.lastSync).toLocaleString();
+                    console.log(`│  🔄 Last sync: ${syncDate.slice(0, 30).padEnd(30)}│`);
+                }
+                console.log('├────────────────────────────────────────────────┤');
+                console.log(`│  🌐 Web: ${(metadata.webUrl || '').slice(0, 36).padEnd(36)}│`);
+                console.log(`│  👁️  Preview: ${(metadata.previewUrl || '').slice(0, 31).padEnd(31)}│`);
+                // Check for local changes
+                if (isAuth) {
+                    try {
+                        const project = await webService.getProject(projectId);
+                        const localFiles = await webService.scanDirectory(targetDir);
+                        const remoteFiles = project.fileSnapshot || {};
+                        const changes = await webService.detectChanges(localFiles, remoteFiles);
+                        const totalChanges = changes.added.length + changes.modified.length + changes.deleted.length;
+                        console.log('├────────────────────────────────────────────────┤');
+                        if (totalChanges === 0) {
+                            console.log('│  ✅ Status: In sync                            │');
+                        }
+                        else {
+                            console.log(`│  ⚠️  Status: ${totalChanges} pending changes`.padEnd(47) + '│');
+                            if (changes.added.length > 0) {
+                                console.log(`│     + ${changes.added.length} new files`.padEnd(44) + '│');
+                            }
+                            if (changes.modified.length > 0) {
+                                console.log(`│     ~ ${changes.modified.length} modified`.padEnd(44) + '│');
+                            }
+                            if (changes.deleted.length > 0) {
+                                console.log(`│     - ${changes.deleted.length} deleted`.padEnd(44) + '│');
+                            }
+                        }
+                    }
+                    catch {
+                        console.log('├────────────────────────────────────────────────┤');
+                        console.log('│  ⚠️  Could not fetch remote status             │');
+                    }
+                }
+            }
+            else {
+                console.log('│  🔗 Linked: No                                 │');
+                console.log('│  💡 Run: recoder web link <projectId>          │');
+            }
+            console.log('└────────────────────────────────────────────────┘\n');
+        }
+        catch (error) {
+            console.error(`❌ ${error.message}`);
+            process.exit(1);
+        }
+    },
+};

package/dist/src/commands/web/unlink.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 'recoder web unlink' command
+ * Remove link between current directory and recoder.xyz project
+ */
+import type { CommandModule } from 'yargs';
+interface UnlinkArgs {
+    directory?: string;
+}
+export declare const unlinkCommand: CommandModule<{}, UnlinkArgs>;
+export {};

package/dist/src/commands/web/unlink.js

@@ -0,0 +1,45 @@
+/**
+ * 'recoder web unlink' command
+ * Remove link between current directory and recoder.xyz project
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+export const unlinkCommand = {
+    command: 'unlink',
+    describe: 'Remove link to recoder.xyz project',
+    builder: (yargs) => yargs.option('directory', {
+        type: 'string',
+        alias: 'd',
+        description: 'Directory to unlink (defaults to current directory)',
+        default: process.cwd(),
+    }),
+    handler: async (argv) => {
+        try {
+            const targetDir = path.resolve(argv.directory || process.cwd());
+            const metadataFile = path.join(targetDir, '.recoder-web');
+            try {
+                await fs.access(metadataFile);
+            }
+            catch {
+                console.log('📂 No project link found in this directory');
+                return;
+            }
+            // Read metadata before deleting
+            let projectId = 'unknown';
+            try {
+                const metadata = JSON.parse(await fs.readFile(metadataFile, 'utf-8'));
+                projectId = metadata.urlId || metadata.projectId || 'unknown';
+            }
+            catch { }
+            await fs.unlink(metadataFile);
+            console.log('✅ Project unlinked successfully');
+            console.log(`📁 Directory: ${targetDir}`);
+            console.log(`🔗 Was linked to: ${projectId}`);
+            console.log('\n💡 Run "recoder web link <projectId>" to link again');
+        }
+        catch (error) {
+            console.error(`❌ ${error.message}`);
+            process.exit(1);
+        }
+    },
+};

package/dist/src/commands/web/watch.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 'recoder web watch' command
+ * Live sync - watch for local changes and sync to web in real-time
+ */
+import type { CommandModule } from 'yargs';
+interface WatchArgs {
+    urlId?: string;
+    directory?: string;
+    'push-only'?: boolean;
+    'pull-only'?: boolean;
+    interval?: number;
+}
+export declare const watchCommand: CommandModule<{}, WatchArgs>;
+export {};