nstantpage-agent 0.6.1 → 0.7.1

package/dist/cli.js

@@ -23,6 +23,7 @@ import { statusCommand } from './commands/status.js';
 import { serviceInstallCommand, serviceUninstallCommand, serviceStatusCommand, serviceStartCommand, serviceStopCommand } from './commands/service.js';
 import { updateCommand } from './commands/update.js';
 import { runCommand } from './commands/run.js';
+import { syncCommand } from './commands/sync.js';
 import { getPackageVersion } from './version.js';
 const program = new Command();
 program
@@ -57,6 +58,17 @@ program
     .description('Open the nstantpage desktop app')
     .option('--local [port]', 'Connect to local backend (default: 5001)')
     .action(runCommand);
+program
+    .command('sync')
+    .description('Sync local directory to nstantpage and start agent')
+    .argument('[directory]', 'Project directory to sync (defaults to current directory)', '.')
+    .option('-p, --port <port>', 'Local dev server port', '3000')
+    .option('-a, --api-port <port>', 'Local API server port', '18924')
+    .option('--gateway <url>', 'Gateway URL (default: from login)')
+    .option('--backend <url>', 'Backend API URL (auto-detected from gateway)')
+    .option('--token <token>', 'Auth token (skip login flow)')
+    .option('--no-start', 'Only sync files, do not start the agent')
+    .action(syncCommand);
 program
     .command('stop')
     .description('Stop the running agent')

package/dist/commands/sync.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sync command — push local files to nstantpage DB and start the agent.
+ *
+ * Usage:
+ *   nstantpage sync              — Sync current directory to nstantpage, then start agent
+ *   nstantpage sync /path/to/dir — Sync a specific directory
+ *
+ * What it does:
+ * 1. Reads all source files in the directory (skips node_modules, .git, dist, etc.)
+ * 2. Creates a LocalRepo project if one doesn't exist (name = folder name)
+ * 3. Pushes all files to the DB (FullFiles table)
+ * 4. Starts the agent (equivalent to `nstantpage start`)
+ */
+interface SyncOptions {
+    port: string;
+    apiPort: string;
+    gateway?: string;
+    backend?: string;
+    token?: string;
+    noStart?: boolean;
+}
+export declare function syncCommand(directory: string, options: SyncOptions): Promise<void>;
+export {};

package/dist/commands/sync.js

@@ -0,0 +1,225 @@
+/**
+ * Sync command — push local files to nstantpage DB and start the agent.
+ *
+ * Usage:
+ *   nstantpage sync              — Sync current directory to nstantpage, then start agent
+ *   nstantpage sync /path/to/dir — Sync a specific directory
+ *
+ * What it does:
+ * 1. Reads all source files in the directory (skips node_modules, .git, dist, etc.)
+ * 2. Creates a LocalRepo project if one doesn't exist (name = folder name)
+ * 3. Pushes all files to the DB (FullFiles table)
+ * 4. Starts the agent (equivalent to `nstantpage start`)
+ */
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import { getConfig, getDeviceId } from '../config.js';
+import { startCommand } from './start.js';
+const SKIP_DIRS = new Set([
+    'node_modules', 'dist', '.git', '.vite-cache', '.next',
+    '__pycache__', '.turbo', '.cache', 'build', 'out',
+    '.svelte-kit', '.nuxt', '.output', '.vercel',
+]);
+const SKIP_FILES = new Set([
+    '.DS_Store', 'Thumbs.db', '.env.local',
+]);
+/** Max file size to sync (1MB — skip large binaries) */
+const MAX_FILE_SIZE = 1_048_576;
+/** Binary file extensions to skip */
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.tiff',
+    '.mp4', '.mp3', '.wav', '.ogg', '.webm', '.avi',
+    '.zip', '.tar', '.gz', '.rar', '.7z',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+    '.exe', '.dll', '.so', '.dylib',
+    '.sqlite', '.db',
+]);
+/**
+ * Resolve the backend API base URL (same logic as start.ts).
+ */
+function resolveBackendUrl(gateway, backend) {
+    if (backend)
+        return backend.replace(/\/$/, '');
+    const isLocal = /^wss?:\/\/(localhost|127\.0\.0\.1)/.test(gateway);
+    return isLocal ? 'http://localhost:5001' : 'https://nstantpage.com';
+}
+/**
+ * Recursively collect all source files in a directory.
+ * Returns array of { relativePath, content }.
+ */
+async function collectFiles(baseDir, currentDir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.nstantpage'))
+                continue;
+            const subFiles = await collectFiles(baseDir, fullPath);
+            files.push(...subFiles);
+        }
+        else if (entry.isFile()) {
+            if (SKIP_FILES.has(entry.name))
+                continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            if (BINARY_EXTENSIONS.has(ext))
+                continue;
+            try {
+                const stat = await fs.promises.stat(fullPath);
+                if (stat.size > MAX_FILE_SIZE)
+                    continue;
+                const content = await fs.promises.readFile(fullPath, 'utf-8');
+                // Skip files with null bytes (binary)
+                if (content.includes('\0'))
+                    continue;
+                files.push({ relativePath, content });
+            }
+            catch {
+                // Can't read — skip
+            }
+        }
+    }
+    return files;
+}
+export async function syncCommand(directory, options) {
+    const conf = getConfig();
+    // Resolve directory
+    const projectDir = path.resolve(directory);
+    if (!fs.existsSync(projectDir)) {
+        console.log(chalk.red(`  ✗ Directory not found: ${projectDir}`));
+        process.exit(1);
+    }
+    // Check authentication
+    const gateway = options.gateway || conf.get('gatewayUrl') || 'wss://webprev.live';
+    const isLocalGateway = /^wss?:\/\/(localhost|127\.0\.0\.1)/.test(gateway);
+    let token = options.token || conf.get('token');
+    if (!token && !isLocalGateway) {
+        console.log(chalk.red('  ✗ Not authenticated. Run "nstantpage login" first.'));
+        process.exit(1);
+    }
+    if (!token && isLocalGateway) {
+        token = 'local-dev';
+    }
+    const backendUrl = resolveBackendUrl(gateway, options.backend);
+    const deviceId = getDeviceId();
+    const folderName = path.basename(projectDir);
+    console.log(chalk.blue(`\n  📂 nstantpage sync\n`));
+    console.log(chalk.gray(`  Directory:  ${projectDir}`));
+    console.log(chalk.gray(`  Backend:    ${backendUrl}\n`));
+    // 1. Collect all files
+    console.log(chalk.gray('  Scanning files...'));
+    const files = await collectFiles(projectDir, projectDir);
+    if (files.length === 0) {
+        console.log(chalk.yellow('  ⚠ No source files found in directory'));
+        process.exit(1);
+    }
+    console.log(chalk.green(`  ✓ Found ${files.length} files`));
+    // 2. Get user info from token
+    let userId;
+    if (token && token !== 'local-dev') {
+        try {
+            const parts = token.split('.');
+            if (parts.length === 3) {
+                const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));
+                userId = payload.sub;
+            }
+        }
+        catch { }
+    }
+    // 3. Create or find LocalRepo project
+    console.log(chalk.gray('  Creating project...'));
+    let projectId;
+    try {
+        const createRes = await fetch(`${backendUrl}/api/projects`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: folderName,
+                type: 'LocalRepo',
+                localFolderPath: projectDir,
+                userId,
+                deviceId,
+            }),
+        });
+        if (!createRes.ok) {
+            const text = await createRes.text().catch(() => '');
+            throw new Error(`Failed to create project (${createRes.status}): ${text}`);
+        }
+        const project = await createRes.json();
+        projectId = String(project.id);
+        console.log(chalk.green(`  ✓ Project: ${project.name} (ID: ${projectId})`));
+    }
+    catch (err) {
+        console.log(chalk.red(`  ✗ ${err.message}`));
+        process.exit(1);
+    }
+    // 4. Push all files to DB
+    console.log(chalk.gray(`  Pushing ${files.length} files to database...`));
+    // Push in batches of 100 to avoid huge payloads
+    const BATCH_SIZE = 100;
+    let totalPushed = 0;
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+        const filesMap = {};
+        for (const f of batch) {
+            filesMap[f.relativePath] = f.content;
+        }
+        try {
+            const pushRes = await fetch(`${backendUrl}/api/sandbox/push-files`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    projectId: parseInt(projectId, 10),
+                    files: filesMap,
+                }),
+            });
+            if (!pushRes.ok) {
+                const text = await pushRes.text().catch(() => '');
+                throw new Error(`Push failed (${pushRes.status}): ${text}`);
+            }
+            totalPushed += batch.length;
+            if (files.length > BATCH_SIZE) {
+                process.stdout.write(`\r  Pushed ${totalPushed}/${files.length} files...`);
+            }
+        }
+        catch (err) {
+            console.log(chalk.red(`\n  ✗ ${err.message}`));
+            process.exit(1);
+        }
+    }
+    if (files.length > BATCH_SIZE)
+        process.stdout.write('\n');
+    console.log(chalk.green(`  ✓ ${totalPushed} files synced to database`));
+    // 5. Start the agent unless --no-start
+    if (options.noStart) {
+        console.log(chalk.blue(`\n  ✓ Sync complete! Project ID: ${projectId}\n`));
+        console.log(chalk.gray(`  To start the agent: nstantpage start --project-id ${projectId} --dir "${projectDir}"`));
+        return;
+    }
+    console.log(chalk.gray('\n  Starting agent...\n'));
+    await startCommand(projectDir, {
+        port: options.port,
+        apiPort: options.apiPort,
+        projectId,
+        gateway,
+        backend: options.backend,
+        token,
+        dir: projectDir,
+    });
+}
+//# sourceMappingURL=sync.js.map

package/dist/gitSetup.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Git Setup — ensures git is installed on the user's machine.
+ * Called during agent startup so GitSnapshotService (backend) can use it for undo.
+ */
+/**
+ * Check if git is available, and try to install it if not.
+ * Returns true if git is available after this call.
+ * Non-blocking: agent continues even if git can't be installed (undo just won't work).
+ */
+export declare function ensureGit(): Promise<boolean>;

package/dist/gitSetup.js

@@ -0,0 +1,162 @@
+/**
+ * Git Setup — ensures git is installed on the user's machine.
+ * Called during agent startup so GitSnapshotService (backend) can use it for undo.
+ */
+import { execSync } from 'child_process';
+import os from 'os';
+import chalk from 'chalk';
+/**
+ * Check if git is available, and try to install it if not.
+ * Returns true if git is available after this call.
+ * Non-blocking: agent continues even if git can't be installed (undo just won't work).
+ */
+export async function ensureGit() {
+    if (isGitAvailable()) {
+        return true;
+    }
+    console.log(chalk.yellow('  ⚠ Git not found — installing (needed for undo/version control)'));
+    const platform = os.platform();
+    try {
+        if (platform === 'darwin') {
+            return await installGitMacOS();
+        }
+        else if (platform === 'win32') {
+            return await installGitWindows();
+        }
+        else {
+            return installGitLinux();
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`  ✗ Could not install git: ${err.message}`));
+        printManualInstructions();
+        return false;
+    }
+}
+function isGitAvailable() {
+    try {
+        execSync('git --version', { stdio: 'pipe', encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function installGitMacOS() {
+    // Check if Xcode CLT is installed (it includes git)
+    try {
+        execSync('xcode-select -p', { stdio: 'pipe' });
+        // CLT installed but git not in PATH — unusual, may need PATH fix
+        console.log(chalk.yellow('  Xcode CLT installed but git not in PATH'));
+        printManualInstructions();
+        return false;
+    }
+    catch {
+        // CLT not installed — trigger installation
+    }
+    // Try Homebrew first (non-interactive, faster)
+    try {
+        execSync('brew --version', { stdio: 'pipe' });
+        console.log(chalk.gray('  Installing git via Homebrew...'));
+        execSync('brew install git', { stdio: 'inherit' });
+        if (isGitAvailable()) {
+            const ver = execSync('git --version', { encoding: 'utf-8' }).trim();
+            console.log(chalk.green(`  ✓ ${ver}`));
+            return true;
+        }
+    }
+    catch {
+        // Homebrew not available — fall through to xcode-select
+    }
+    // Trigger Xcode CLT install dialog
+    console.log(chalk.gray('  Installing Xcode Command Line Tools (includes git)...'));
+    console.log(chalk.gray('  Please click "Install" in the dialog if prompted.'));
+    try {
+        execSync('xcode-select --install 2>/dev/null', { stdio: 'inherit' });
+    }
+    catch {
+        // xcode-select --install returns non-zero if dialog was shown
+    }
+    // Poll for git availability (max 5 minutes — the Xcode dialog is async)
+    const maxWaitMs = 300_000;
+    const pollMs = 5_000;
+    const start = Date.now();
+    while (Date.now() - start < maxWaitMs) {
+        await new Promise(r => setTimeout(r, pollMs));
+        if (isGitAvailable()) {
+            const ver = execSync('git --version', { encoding: 'utf-8' }).trim();
+            console.log(chalk.green(`  ✓ ${ver}`));
+            return true;
+        }
+    }
+    console.log(chalk.yellow('  ⚠ Timed out waiting for install. Restart after Xcode Tools finishes.'));
+    return false;
+}
+async function installGitWindows() {
+    // Try winget (available on Windows 10 1709+)
+    try {
+        execSync('winget --version', { stdio: 'pipe' });
+        console.log(chalk.gray('  Installing git via winget...'));
+        execSync('winget install --id Git.Git -e --source winget --accept-package-agreements --accept-source-agreements', { stdio: 'inherit' });
+        if (isGitAvailable()) {
+            const ver = execSync('git --version', { encoding: 'utf-8' }).trim();
+            console.log(chalk.green(`  ✓ ${ver}`));
+            return true;
+        }
+        // winget installs may need a new shell for PATH update
+        console.log(chalk.yellow('  Git installed — restart your terminal for PATH to update.'));
+        return false;
+    }
+    catch {
+        // winget not available
+    }
+    console.log(chalk.yellow('  Install Git for Windows:'));
+    console.log(chalk.gray('    https://git-scm.com/download/win'));
+    console.log(chalk.gray('    or: winget install --id Git.Git'));
+    return false;
+}
+function installGitLinux() {
+    // Try common package managers (non-interactive)
+    const managers = [
+        { check: 'apt-get --version', install: 'sudo apt-get install -y git' },
+        { check: 'dnf --version', install: 'sudo dnf install -y git' },
+        { check: 'yum --version', install: 'sudo yum install -y git' },
+        { check: 'pacman --version', install: 'sudo pacman -S --noconfirm git' },
+        { check: 'apk --version', install: 'sudo apk add git' },
+    ];
+    for (const { check, install } of managers) {
+        try {
+            execSync(check, { stdio: 'pipe' });
+            console.log(chalk.gray(`  Installing git: ${install}`));
+            execSync(install, { stdio: 'inherit' });
+            if (isGitAvailable()) {
+                const ver = execSync('git --version', { encoding: 'utf-8' }).trim();
+                console.log(chalk.green(`  ✓ ${ver}`));
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    console.log(chalk.yellow('  Please install git:'));
+    console.log(chalk.gray('    Ubuntu/Debian: sudo apt-get install git'));
+    console.log(chalk.gray('    Fedora:        sudo dnf install git'));
+    console.log(chalk.gray('    Arch:          sudo pacman -S git'));
+    return false;
+}
+function printManualInstructions() {
+    const platform = os.platform();
+    console.log(chalk.yellow('  Install git manually:'));
+    if (platform === 'darwin') {
+        console.log(chalk.gray('    xcode-select --install'));
+        console.log(chalk.gray('    or: brew install git'));
+    }
+    else if (platform === 'win32') {
+        console.log(chalk.gray('    https://git-scm.com/download/win'));
+    }
+    else {
+        console.log(chalk.gray('    sudo apt-get install git'));
+    }
+}
+//# sourceMappingURL=gitSetup.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {