nstantpage-agent 0.2.0

package/dist/commands/start.js

@@ -0,0 +1,140 @@
+/**
+ * Start command — launch the nstantpage agent
+ *
+ * Architecture:
+ * 1. Start local API server (handles /live/* requests for file sync, checks, etc.)
+ * 2. Start local dev server (Vite/Next.js — runs project on user's machine)
+ * 3. Connect tunnel to gateway (relays requests from cloud to local machine)
+ *
+ * The agent fully replaces Docker containers:
+ * - Files are on the user's disk (no docker cp needed)
+ * - Dev server runs natively (no container overhead)
+ * - Type checking runs locally (full IDE speed)
+ * - Package installation uses local npm/pnpm
+ */
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import { getConfig } from '../config.js';
+import { TunnelClient } from '../tunnel.js';
+import { LocalServer } from '../localServer.js';
+export async function startCommand(directory, options) {
+    const conf = getConfig();
+    // Check authentication
+    const token = conf.get('token');
+    if (!token) {
+        console.log(chalk.red('✗ Not authenticated. Run "nstantpage login" first.'));
+        process.exit(1);
+    }
+    // Resolve project directory
+    const projectDir = path.resolve(directory);
+    if (!fs.existsSync(projectDir)) {
+        console.log(chalk.red(`✗ Directory not found: ${projectDir}`));
+        process.exit(1);
+    }
+    // Verify it's a project directory
+    if (!fs.existsSync(path.join(projectDir, 'package.json'))) {
+        console.log(chalk.red(`✗ No package.json found in ${projectDir}`));
+        console.log(chalk.gray('  Make sure you\'re in a project directory'));
+        process.exit(1);
+    }
+    const devPort = parseInt(options.port, 10);
+    const apiPort = parseInt(options.apiPort, 10);
+    // Determine project ID
+    let projectId = options.projectId || conf.get('projectId');
+    // Try .nstantpage.json in project dir
+    const localConfig = path.join(projectDir, '.nstantpage.json');
+    if (!projectId && fs.existsSync(localConfig)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(localConfig, 'utf-8'));
+            projectId = data.projectId;
+        }
+        catch { }
+    }
+    if (!projectId) {
+        console.log(chalk.yellow('⚠ No project ID specified.'));
+        console.log(chalk.gray('  Use --project-id <id> or create a .nstantpage.json file'));
+        console.log(chalk.gray('  with { "projectId": "<your-project-id>" }'));
+        process.exit(1);
+    }
+    // Save project ID
+    conf.set('projectId', projectId);
+    console.log(chalk.blue(`\n🚀 nstantpage agent v0.2.0\n`));
+    console.log(chalk.gray(`  Directory:    ${projectDir}`));
+    console.log(chalk.gray(`  Project ID:   ${projectId}`));
+    console.log(chalk.gray(`  Dev server:   port ${devPort}`));
+    console.log(chalk.gray(`  API server:   port ${apiPort}`));
+    console.log(chalk.gray(`  Gateway:      ${options.gateway}\n`));
+    // 1. Start local server (API + dev server)
+    const localServer = new LocalServer({
+        projectDir,
+        projectId,
+        apiPort,
+        devPort,
+    });
+    // 2. Create tunnel client
+    const tunnel = new TunnelClient({
+        gatewayUrl: options.gateway,
+        token,
+        projectId,
+        apiPort,
+        devPort,
+    });
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        console.log(chalk.yellow('\n\n  Shutting down...\n'));
+        tunnel.disconnect();
+        await localServer.stop();
+        conf.delete('agentPid');
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    // Store PID for "nstantpage stop"
+    conf.set('agentPid', process.pid);
+    try {
+        // Start local API server
+        console.log(chalk.gray('  Starting local API server...'));
+        await localServer.start();
+        console.log(chalk.green(`  ✓ API server on port ${apiPort}`));
+        // Start dev server unless --no-dev flag
+        if (!options.noDev) {
+            console.log(chalk.gray('  Starting dev server...'));
+            try {
+                const devServer = localServer.getDevServer();
+                await devServer.start();
+                console.log(chalk.green(`  ✓ Dev server on port ${devPort}`));
+            }
+            catch (err) {
+                console.log(chalk.yellow(`  ⚠ Dev server failed to start: ${err.message}`));
+                console.log(chalk.gray('    You can start it later from the editor'));
+            }
+        }
+        else {
+            console.log(chalk.gray('  Dev server skipped (--no-dev)'));
+        }
+        // Connect tunnel to gateway
+        console.log(chalk.gray('  Connecting to gateway...'));
+        await tunnel.connect();
+        console.log(chalk.green(`  ✓ Tunnel connected\n`));
+        // Display status
+        console.log(chalk.blue.bold(`  ┌──────────────────────────────────────────────┐`));
+        console.log(chalk.blue.bold(`  │  Your project is live!                       │`));
+        console.log(chalk.blue.bold(`  ├──────────────────────────────────────────────┤`));
+        console.log(chalk.white(`  │  Cloud:  https://${projectId}.webprev.live`));
+        console.log(chalk.white(`  │  Local:  http://localhost:${devPort}`));
+        console.log(chalk.blue.bold(`  └──────────────────────────────────────────────┘\n`));
+        console.log(chalk.gray(`  Mode: ${chalk.green('Agent')} (no containers needed)`));
+        console.log(chalk.gray(`  All builds, checks, and previews run on this machine.`));
+        console.log(chalk.gray(`  Press Ctrl+C to stop\n`));
+        // Keep alive
+        await new Promise(() => { });
+    }
+    catch (err) {
+        console.error(chalk.red(`\n✗ Failed to start: ${err.message}`));
+        await localServer.stop();
+        conf.delete('agentPid');
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=start.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Status command — show agent connection status
+ */
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,53 @@
+/**
+ * Status command — show agent connection status
+ */
+import chalk from 'chalk';
+import { getConfig } from '../config.js';
+export async function statusCommand() {
+    const conf = getConfig();
+    const token = conf.get('token');
+    const projectId = conf.get('projectId');
+    const pid = conf.get('agentPid');
+    const lastConnected = conf.get('lastConnected');
+    const devPort = conf.get('devPort') || 3000;
+    const apiPort = conf.get('apiPort') || 18924;
+    console.log(chalk.blue('\n  nstantpage agent v0.2.0\n'));
+    // Auth
+    if (token) {
+        console.log(chalk.green('  ✓ Authenticated'));
+    }
+    else {
+        console.log(chalk.red('  ✗ Not authenticated (run "nstantpage login")'));
+    }
+    // Project
+    if (projectId) {
+        console.log(chalk.gray(`  Project:    ${projectId}`));
+        console.log(chalk.gray(`  Preview:    https://${projectId}.webprev.live`));
+    }
+    else {
+        console.log(chalk.gray('  No project linked'));
+    }
+    // Running
+    if (pid) {
+        try {
+            process.kill(pid, 0); // Check if process exists
+            console.log(chalk.green(`  ✓ Agent running (PID ${pid})`));
+            console.log(chalk.gray(`    Dev server: http://localhost:${devPort}`));
+            console.log(chalk.gray(`    API server: http://localhost:${apiPort}`));
+        }
+        catch {
+            console.log(chalk.gray('  Agent not running'));
+            conf.delete('agentPid');
+        }
+    }
+    else {
+        console.log(chalk.gray('  Agent not running'));
+    }
+    // Last connected
+    if (lastConnected) {
+        console.log(chalk.gray(`  Last connected: ${lastConnected}`));
+    }
+    console.log(chalk.gray(`\n  Mode: Agent (replaces cloud containers)`));
+    console.log('');
+}
+//# sourceMappingURL=status.js.map

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent configuration store (persisted to disk)
+ */
+import Conf from 'conf';
+export declare function getConfig(): Conf;

package/dist/config.js

@@ -0,0 +1,23 @@
+/**
+ * Agent configuration store (persisted to disk)
+ */
+import Conf from 'conf';
+let _conf = null;
+export function getConfig() {
+    if (!_conf) {
+        _conf = new Conf({
+            projectName: 'nstantpage-agent',
+            schema: {
+                token: { type: 'string', default: '' },
+                gatewayUrl: { type: 'string', default: 'wss://webprev.live' },
+                projectId: { type: 'string', default: '' },
+                agentPid: { type: 'number' },
+                lastConnected: { type: 'string' },
+                devPort: { type: 'number', default: 3000 },
+                apiPort: { type: 'number', default: 18924 },
+            },
+        });
+    }
+    return _conf;
+}
+//# sourceMappingURL=config.js.map

package/dist/devServer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Dev Server — manages the local development server process.
+ * Enhanced version of runner.ts with log capturing and lifecycle management.
+ *
+ * Replaces the container-based dev server (docker exec npx vite).
+ */
+export interface DevServerOptions {
+    projectDir: string;
+    port: number;
+    env?: Record<string, string>;
+}
+export interface LogEntry {
+    timestamp: number;
+    type: 'stdout' | 'stderr';
+    message: string;
+}
+export declare class DevServer {
+    private options;
+    private process;
+    private backendProcess;
+    private logs;
+    private maxLogs;
+    private _isRunning;
+    private startedAt;
+    constructor(options: DevServerOptions);
+    get isRunning(): boolean;
+    get port(): number;
+    get uptime(): number;
+    /**
+     * Start the dev server based on project type detection.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all dev server processes.
+     */
+    stop(): Promise<void>;
+    /**
+     * Restart the dev server.
+     */
+    restart(): Promise<void>;
+    /**
+     * Get recent logs.
+     */
+    getLogs(limit?: number): LogEntry[];
+    /**
+     * Get resource usage stats.
+     */
+    getStats(): {
+        cpuPercent: number;
+        memoryMb: number;
+        pid: number | null;
+    };
+    /**
+     * Execute a command in the project directory.
+     */
+    exec(command: string, timeoutMs?: number): Promise<{
+        exitCode: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    private captureOutput;
+    private addLog;
+    private killProcess;
+    private waitForReady;
+}

package/dist/devServer.js

@@ -0,0 +1,308 @@
+/**
+ * Dev Server — manages the local development server process.
+ * Enhanced version of runner.ts with log capturing and lifecycle management.
+ *
+ * Replaces the container-based dev server (docker exec npx vite).
+ */
+import { spawn, execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import http from 'http';
+import os from 'os';
+export class DevServer {
+    options;
+    process = null;
+    backendProcess = null;
+    logs = [];
+    maxLogs = 500;
+    _isRunning = false;
+    startedAt = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    get isRunning() {
+        return this._isRunning;
+    }
+    get port() {
+        return this.options.port;
+    }
+    get uptime() {
+        return this._isRunning ? Date.now() - this.startedAt : 0;
+    }
+    /**
+     * Start the dev server based on project type detection.
+     */
+    async start() {
+        if (this._isRunning) {
+            console.log('  [DevServer] Already running, restarting...');
+            await this.stop();
+        }
+        const { projectDir, port } = this.options;
+        const extraEnv = this.options.env || {};
+        // Detect project type
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`No package.json found in ${projectDir}`);
+        }
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const hasVite = 'vite' in deps;
+        const hasNext = 'next' in deps;
+        const hasBackend = fs.existsSync(path.join(projectDir, 'server', 'index.ts')) ||
+            fs.existsSync(path.join(projectDir, 'server', 'index.js'));
+        this.logs = [];
+        this.startedAt = Date.now();
+        // Start backend if present
+        if (hasBackend) {
+            const backendPort = port + 1000;
+            const backendEntry = fs.existsSync(path.join(projectDir, 'server', 'index.ts'))
+                ? 'server/index.ts'
+                : 'server/index.js';
+            console.log(`  [DevServer] Starting backend (port ${backendPort})...`);
+            this.backendProcess = spawn('npx', ['tsx', backendEntry], {
+                cwd: projectDir,
+                env: {
+                    ...process.env,
+                    ...extraEnv,
+                    PORT: String(backendPort),
+                    NODE_ENV: 'development',
+                },
+                shell: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.captureOutput(this.backendProcess, 'backend');
+        }
+        // Start frontend dev server
+        let cmd;
+        let args;
+        if (hasNext) {
+            cmd = 'npx';
+            args = ['next', 'dev', '-p', String(port)];
+        }
+        else if (hasVite) {
+            cmd = 'npx';
+            args = ['vite', '--port', String(port), '--host', '0.0.0.0', '--strictPort'];
+        }
+        else if (pkg.scripts?.dev) {
+            cmd = 'npm';
+            args = ['run', 'dev'];
+        }
+        else if (pkg.scripts?.start) {
+            cmd = 'npm';
+            args = ['start'];
+        }
+        else {
+            throw new Error('Could not detect dev server command');
+        }
+        const frontendEnv = {
+            ...process.env,
+            ...extraEnv,
+            PORT: String(port),
+        };
+        if (hasBackend) {
+            frontendEnv['VITE_BACKEND_PORT'] = String(port + 1000);
+        }
+        console.log(`  [DevServer] Starting: ${cmd} ${args.join(' ')} (port ${port})`);
+        this.process = spawn(cmd, args, {
+            cwd: projectDir,
+            env: frontendEnv,
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.captureOutput(this.process, 'frontend');
+        this.process.on('close', (code) => {
+            this._isRunning = false;
+            this.addLog('stderr', `Dev server exited with code ${code}`);
+            console.log(`  [DevServer] Process exited (code ${code})`);
+        });
+        this.process.on('error', (err) => {
+            this._isRunning = false;
+            this.addLog('stderr', `Dev server error: ${err.message}`);
+            console.error(`  [DevServer] Error: ${err.message}`);
+        });
+        this._isRunning = true;
+        // Wait for server to be ready
+        try {
+            await this.waitForReady(port, 30_000);
+            console.log(`  [DevServer] Ready on port ${port}`);
+        }
+        catch {
+            console.warn(`  [DevServer] Health check timed out, but server may still be starting`);
+        }
+    }
+    /**
+     * Stop all dev server processes.
+     */
+    async stop() {
+        const kills = [];
+        if (this.process) {
+            kills.push(this.killProcess(this.process));
+            this.process = null;
+        }
+        if (this.backendProcess) {
+            kills.push(this.killProcess(this.backendProcess));
+            this.backendProcess = null;
+        }
+        await Promise.all(kills);
+        this._isRunning = false;
+        console.log('  [DevServer] Stopped');
+    }
+    /**
+     * Restart the dev server.
+     */
+    async restart() {
+        await this.stop();
+        await new Promise(r => setTimeout(r, 500));
+        await this.start();
+    }
+    /**
+     * Get recent logs.
+     */
+    getLogs(limit = 100) {
+        return this.logs.slice(-limit);
+    }
+    /**
+     * Get resource usage stats.
+     */
+    getStats() {
+        if (!this.process || !this.process.pid) {
+            return { cpuPercent: 0, memoryMb: 0, pid: null };
+        }
+        try {
+            const pid = this.process.pid;
+            const platform = os.platform();
+            let output;
+            if (platform === 'win32') {
+                // Windows: use wmic or tasklist
+                output = execSync(`wmic process where ProcessId=${pid} get WorkingSetSize /format:value`, { encoding: 'utf-8', timeout: 3000 }).trim();
+                const match = output.match(/WorkingSetSize=(\d+)/);
+                const bytes = match ? parseInt(match[1], 10) : 0;
+                return {
+                    cpuPercent: 0, // CPU% hard to get on Windows without sampling
+                    memoryMb: bytes / (1024 * 1024),
+                    pid,
+                };
+            }
+            else {
+                // macOS / Linux: use ps
+                output = execSync(`ps -p ${pid} -o %cpu=,rss= 2>/dev/null`, { encoding: 'utf-8', timeout: 2000 }).trim();
+                const [cpu, rss] = output.split(/\s+/).map(Number);
+                return {
+                    cpuPercent: cpu || 0,
+                    memoryMb: (rss || 0) / 1024, // rss is in KB
+                    pid,
+                };
+            }
+        }
+        catch {
+            return { cpuPercent: 0, memoryMb: 0, pid: this.process.pid };
+        }
+    }
+    /**
+     * Execute a command in the project directory.
+     */
+    async exec(command, timeoutMs = 30_000) {
+        return new Promise((resolve) => {
+            const isWin = os.platform() === 'win32';
+            const shell = isWin ? 'cmd' : 'sh';
+            const shellArgs = isWin ? ['/c', command] : ['-c', command];
+            const proc = spawn(shell, shellArgs, {
+                cwd: this.options.projectDir,
+                env: process.env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+            proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+            proc.on('close', (code) => {
+                resolve({ exitCode: code ?? 1, stdout, stderr });
+            });
+            proc.on('error', (err) => {
+                resolve({ exitCode: 1, stdout, stderr: err.message });
+            });
+            setTimeout(() => {
+                try {
+                    proc.kill();
+                }
+                catch { }
+                resolve({ exitCode: 1, stdout, stderr: stderr + '\nCommand timed out' });
+            }, timeoutMs);
+        });
+    }
+    captureOutput(proc, source) {
+        proc.stdout?.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (msg) {
+                this.addLog('stdout', msg);
+                process.stdout.write(`  [${source}] ${msg}\n`);
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (msg) {
+                this.addLog('stderr', msg);
+                // Only print actual errors, not noisy warnings
+                if (!msg.includes('[BABEL] Note:') && !msg.includes('at-rule-no-unknown')) {
+                    process.stderr.write(`  [${source}] ${msg}\n`);
+                }
+            }
+        });
+    }
+    addLog(type, message) {
+        this.logs.push({ timestamp: Date.now(), type, message });
+        if (this.logs.length > this.maxLogs) {
+            this.logs = this.logs.slice(-this.maxLogs);
+        }
+    }
+    killProcess(proc) {
+        return new Promise((resolve) => {
+            if (!proc.pid) {
+                resolve();
+                return;
+            }
+            try {
+                // Try graceful shutdown first
+                proc.kill('SIGTERM');
+                const forceKill = setTimeout(() => {
+                    try {
+                        proc.kill();
+                    }
+                    catch { }
+                    resolve();
+                }, 5000);
+                proc.on('close', () => {
+                    clearTimeout(forceKill);
+                    resolve();
+                });
+            }
+            catch {
+                resolve();
+            }
+        });
+    }
+    waitForReady(port, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const start = Date.now();
+            const check = () => {
+                if (Date.now() - start > timeoutMs) {
+                    reject(new Error('Timeout'));
+                    return;
+                }
+                const req = http.get(`http://localhost:${port}/`, (res) => {
+                    res.resume();
+                    resolve();
+                });
+                req.on('error', () => {
+                    setTimeout(check, 500);
+                });
+                req.setTimeout(2000, () => {
+                    req.destroy();
+                    setTimeout(check, 500);
+                });
+            };
+            setTimeout(check, 1000);
+        });
+    }
+}
+//# sourceMappingURL=devServer.js.map

package/dist/errorStore.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Error Store — tracks build, type, lint, and runtime errors for a project.
+ * This replaces the container-based error tracking from the gateway.
+ */
+export interface StructuredError {
+    file?: string;
+    line?: number;
+    col?: number;
+    message: string;
+    type: 'build' | 'type' | 'lint' | 'hard' | 'runtime';
+    code?: string;
+    signature: string;
+    raw?: string;
+}
+export declare class ErrorStore {
+    private buildErrors;
+    private typeErrors;
+    private lintErrors;
+    private runtimeErrors;
+    setBuildErrors(errors: StructuredError[]): void;
+    setTypeErrors(errors: StructuredError[]): void;
+    setLintErrors(errors: StructuredError[]): void;
+    addRuntimeError(error: StructuredError): void;
+    clearRuntimeErrors(): void;
+    clearAll(): void;
+    getAllErrors(): StructuredError[];
+    getErrorsByType(): {
+        buildErrors: string[];
+        typeErrors: string[];
+        lintErrors: string[];
+        runtimeErrors: string[];
+    };
+    getStructuredByType(): {
+        buildErrors: StructuredError[];
+        typeErrors: StructuredError[];
+        lintErrors: StructuredError[];
+        runtimeErrors: StructuredError[];
+    };
+}
+/**
+ * Convert structured error to display string.
+ */
+export declare function structuredErrorToString(error: StructuredError): string;
+/**
+ * Parse a raw error string into a structured error.
+ */
+export declare function parseErrorString(errorStr: string, defaultType?: StructuredError['type']): StructuredError;
+/**
+ * Filter non-error messages (Babel notes, CSS at-rule warnings, etc.)
+ */
+export declare function filterNonErrors(errors: string[]): string[];