nstantpage-agent 0.2.0

package/dist/localServer.js

@@ -0,0 +1,555 @@
+/**
+ * Local Server — handles /live/* API requests on the user's machine.
+ *
+ * This replaces the PreviewGateway + Docker container workflow:
+ * - File sync (write files, track changes)
+ * - Type checking (run tsc locally)
+ * - Error tracking (build, type, runtime)
+ * - Package installation (npm/pnpm install)
+ * - Dev server management (start, stop, restart)
+ * - Terminal execution (run commands in project dir)
+ * - Logs and stats
+ *
+ * Requests arrive through the tunnel from the gateway.
+ */
+import http from 'http';
+import os from 'os';
+import { DevServer } from './devServer.js';
+import { FileManager } from './fileManager.js';
+import { Checker } from './checker.js';
+import { ErrorStore, structuredErrorToString } from './errorStore.js';
+import { PackageInstaller } from './packageInstaller.js';
+export class LocalServer {
+    server = null;
+    options;
+    devServer;
+    fileManager;
+    checker;
+    errorStore;
+    packageInstaller;
+    lastHeartbeat = Date.now();
+    constructor(options) {
+        this.options = options;
+        this.devServer = new DevServer({
+            projectDir: options.projectDir,
+            port: options.devPort,
+            env: options.env,
+        });
+        this.fileManager = new FileManager({ projectDir: options.projectDir });
+        this.checker = new Checker({ projectDir: options.projectDir, projectId: options.projectId });
+        this.errorStore = new ErrorStore();
+        this.packageInstaller = new PackageInstaller({ projectDir: options.projectDir });
+    }
+    getDevServer() {
+        return this.devServer;
+    }
+    getApiPort() {
+        return this.options.apiPort;
+    }
+    getDevPort() {
+        return this.options.devPort;
+    }
+    async start() {
+        this.server = http.createServer(async (req, res) => {
+            // CORS
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            if (req.method === 'OPTIONS') {
+                res.statusCode = 204;
+                res.end();
+                return;
+            }
+            try {
+                await this.handleRequest(req, res);
+            }
+            catch (error) {
+                console.error(`  [LocalServer] Error handling ${req.url}: ${error.message}`);
+                if (!res.headersSent) {
+                    res.statusCode = 500;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ success: false, error: error.message }));
+                }
+            }
+        });
+        await new Promise((resolve, reject) => {
+            this.server.listen(this.options.apiPort, '127.0.0.1', () => {
+                console.log(`  [LocalServer] API server on port ${this.options.apiPort}`);
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    async stop() {
+        await this.devServer.stop();
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url || '/', `http://localhost`);
+        const pathOnly = url.pathname;
+        // Route to handler
+        const handler = this.getHandler(pathOnly);
+        if (handler) {
+            const body = await this.collectBody(req);
+            await handler.call(this, req, res, body, url);
+        }
+        else {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: `Unknown endpoint: ${pathOnly}` }));
+        }
+    }
+    getHandler(path) {
+        // Exact matches first
+        const handlers = {
+            '/live/sync': this.handleSync,
+            '/live/files': this.handleFiles,
+            '/live/check': this.handleCheck,
+            '/live/errors': this.handleErrors,
+            '/live/reload': this.handleReload,
+            '/live/runtime-error': this.handleRuntimeError,
+            '/live/install': this.handleInstall,
+            '/live/exec': this.handleExec,
+            '/live/terminal': this.handleTerminal,
+            '/live/container-status': this.handleContainerStatus,
+            '/live/container-stats': this.handleContainerStats,
+            '/live/logs': this.handleLogs,
+            '/live/dev': this.handleDev,
+            '/live/dev/restart': this.handleDevRestart,
+            '/live/dev/stop': this.handleDevStop,
+            '/live/open': this.handleOpen,
+            '/live/close': this.handleClose,
+            '/live/heartbeat': this.handleHeartbeat,
+            '/live/hard-patterns': this.handleHardPatterns,
+            '/live/hard-patterns-batch': this.handleHardPatternsBatch,
+            '/live/normalize': this.handleNormalize,
+            '/live/normalize-batch': this.handleNormalizeBatch,
+            '/live/invalidate': this.handleInvalidate,
+            '/live/refetch': this.handleRefetch,
+            '/live/grace-period': this.handleGracePeriod,
+            '/live/stats': this.handleStats,
+            '/live/usage': this.handleUsage,
+            '/health': this.handleHealth,
+        };
+        if (handlers[path])
+            return handlers[path];
+        // Prefix matches (e.g., /live/errors/123, /live/logs/123)
+        for (const [route, handler] of Object.entries(handlers)) {
+            if (path.startsWith(route + '/'))
+                return handler;
+        }
+        return null;
+    }
+    // ─── /live/sync ──────────────────────────────────────────────
+    async handleSync(_req, res, body) {
+        const data = JSON.parse(body);
+        const { files, deletedFiles, filterFiles } = data;
+        let filesWritten = 0;
+        let filesDeleted = 0;
+        // Write files
+        if (files && typeof files === 'object' && Object.keys(files).length > 0) {
+            const result = await this.fileManager.writeFiles(files);
+            filesWritten = result.filesWritten;
+        }
+        // Delete files
+        if (deletedFiles && Array.isArray(deletedFiles) && deletedFiles.length > 0) {
+            filesDeleted = await this.fileManager.deleteFiles(deletedFiles);
+        }
+        // Run type check
+        const filesToCheck = filterFiles || (files ? Object.keys(files) : []);
+        const { typeErrors, allErrors } = await this.checker.fullCheck(filesToCheck.length > 0 ? filesToCheck : undefined);
+        // Update error store
+        this.errorStore.setTypeErrors(typeErrors);
+        // Format response (matching gateway format)
+        const structuredErrors = allErrors;
+        const errorStrings = structuredErrors.map(structuredErrorToString);
+        this.json(res, {
+            success: true,
+            filesWritten,
+            filesDeleted,
+            structuredErrors,
+            errors: errorStrings,
+            errorCount: structuredErrors.length,
+        });
+    }
+    // ─── /live/files ─────────────────────────────────────────────
+    async handleFiles(_req, res, body) {
+        const data = JSON.parse(body);
+        const { files } = data;
+        if (!files) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing files' });
+            return;
+        }
+        const result = await this.fileManager.writeFiles(files);
+        this.json(res, { success: true, filesWritten: result.filesWritten });
+    }
+    // ─── /live/check ─────────────────────────────────────────────
+    async handleCheck(_req, res, body) {
+        const data = body ? JSON.parse(body) : {};
+        const { filterFiles, autoRepair } = data;
+        const { typeErrors, allErrors } = await this.checker.fullCheck(filterFiles);
+        this.errorStore.setTypeErrors(typeErrors);
+        const structuredErrors = allErrors;
+        const errorStrings = structuredErrors.map(structuredErrorToString);
+        this.json(res, {
+            success: true,
+            structuredErrors,
+            errors: errorStrings,
+            errorCount: structuredErrors.length,
+            repairsApplied: false,
+        });
+    }
+    // ─── /live/errors ────────────────────────────────────────────
+    async handleErrors(_req, res, _body, url) {
+        // Try to extract projectId from URL path (e.g., /live/errors/123)
+        // Run a fresh check for accurate errors
+        const { typeErrors, allErrors } = await this.checker.fullCheck();
+        this.errorStore.setTypeErrors(typeErrors);
+        const all = this.errorStore.getAllErrors();
+        const byType = this.errorStore.getErrorsByType();
+        this.json(res, {
+            success: true,
+            errors: all.map(structuredErrorToString),
+            structuredErrors: all,
+            errorCount: all.length,
+            ...byType,
+        });
+    }
+    // ─── /live/reload ────────────────────────────────────────────
+    async handleReload(_req, res, body) {
+        // In local mode, Vite HMR handles reloading automatically.
+        // We just acknowledge the request.
+        this.json(res, { success: true, message: 'HMR handled by local dev server' });
+    }
+    // ─── /live/runtime-error ─────────────────────────────────────
+    async handleRuntimeError(_req, res, body) {
+        const data = JSON.parse(body);
+        const { error: errorMsg, file, line, col, stack } = data;
+        const message = errorMsg || 'Unknown runtime error';
+        const signature = `runtime:${file || 'unknown'}:${line || 0}:${message.substring(0, 100)}`;
+        this.errorStore.addRuntimeError({
+            file,
+            line,
+            col,
+            message,
+            type: 'runtime',
+            signature,
+            raw: stack || errorMsg,
+        });
+        this.json(res, { success: true });
+    }
+    // ─── /live/install ───────────────────────────────────────────
+    async handleInstall(_req, res, body) {
+        const data = JSON.parse(body);
+        const { packages, dev } = data;
+        if (!packages || !Array.isArray(packages) || packages.length === 0) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing packages array' });
+            return;
+        }
+        const result = await this.packageInstaller.install(packages, dev);
+        this.json(res, {
+            success: result.success,
+            output: result.output,
+            installedPackages: result.installedPackages,
+        });
+    }
+    // ─── /live/exec ──────────────────────────────────────────────
+    async handleExec(_req, res, body) {
+        const data = JSON.parse(body);
+        const { command } = data;
+        if (!command) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing command' });
+            return;
+        }
+        const result = await this.devServer.exec(command);
+        this.json(res, result);
+    }
+    // ─── /live/terminal ──────────────────────────────────────────
+    async handleTerminal(_req, res, body) {
+        const data = JSON.parse(body);
+        const { command, cwd } = data;
+        if (!command) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing command' });
+            return;
+        }
+        const result = await this.devServer.exec(command);
+        this.json(res, {
+            success: result.exitCode === 0,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        });
+    }
+    // ─── /live/container-status ──────────────────────────────────
+    async handleContainerStatus(_req, res, _body, url) {
+        this.json(res, {
+            running: this.devServer.isRunning,
+            mode: 'agent',
+            agentMode: true,
+            hostname: os.hostname(),
+            platform: `${os.platform()} ${os.arch()}`,
+        });
+    }
+    // ─── /live/container-stats ───────────────────────────────────
+    async handleContainerStats(_req, res) {
+        const stats = this.devServer.getStats();
+        const totalMem = os.totalmem() / (1024 * 1024);
+        const freeMem = os.freemem() / (1024 * 1024);
+        this.json(res, {
+            success: true,
+            agentMode: true,
+            cpu: { percent: stats.cpuPercent, cores: os.cpus().length },
+            memory: {
+                usedMb: stats.memoryMb,
+                totalMb: Math.round(totalMem),
+                freeMb: Math.round(freeMem),
+                percent: totalMem > 0 ? Math.round((stats.memoryMb / totalMem) * 100) : 0,
+            },
+            pid: stats.pid,
+            uptime: this.devServer.uptime,
+        });
+    }
+    // ─── /live/logs ──────────────────────────────────────────────
+    async handleLogs(_req, res, _body, url) {
+        const limit = parseInt(url.searchParams.get('limit') || '100', 10);
+        const logs = this.devServer.getLogs(limit);
+        this.json(res, {
+            success: true,
+            logs: logs.map(l => ({
+                timestamp: new Date(l.timestamp).toISOString(),
+                type: l.type,
+                message: l.message,
+                source: 'frontend',
+            })),
+        });
+    }
+    // ─── /live/dev ───────────────────────────────────────────────
+    async handleDev(_req, res, body) {
+        try {
+            // Ensure dependencies are installed
+            await this.packageInstaller.ensureDependencies();
+            // Start dev server
+            await this.devServer.start();
+            this.json(res, {
+                success: true,
+                port: this.options.devPort,
+                mode: 'agent',
+                previewUrl: `http://localhost:${this.options.devPort}/`,
+            });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { success: false, error: err.message });
+        }
+    }
+    // ─── /live/dev/restart ───────────────────────────────────────
+    async handleDevRestart(_req, res) {
+        try {
+            await this.devServer.restart();
+            this.json(res, { success: true, message: 'Dev server restarted' });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { success: false, error: err.message });
+        }
+    }
+    // ─── /live/dev/stop ──────────────────────────────────────────
+    async handleDevStop(_req, res) {
+        await this.devServer.stop();
+        this.json(res, { success: true, message: 'Dev server stopped' });
+    }
+    // ─── /live/open ──────────────────────────────────────────────
+    async handleOpen(_req, res) {
+        try {
+            // Ensure deps are installed
+            await this.packageInstaller.ensureDependencies();
+            // Start dev server if not running
+            if (!this.devServer.isRunning) {
+                await this.devServer.start();
+            }
+            this.json(res, {
+                success: true,
+                port: this.options.devPort,
+                previewUrl: `http://localhost:${this.options.devPort}/`,
+                mode: 'agent',
+                agentMode: true,
+            });
+        }
+        catch (err) {
+            res.statusCode = 500;
+            this.json(res, { success: false, error: err.message });
+        }
+    }
+    // ─── /live/close ─────────────────────────────────────────────
+    async handleClose(_req, res) {
+        // Don't stop the dev server on close — user is still working locally.
+        // Just acknowledge.
+        this.json(res, { success: true, message: 'Acknowledged (agent keeps running)' });
+    }
+    // ─── /live/heartbeat ────────────────────────────────────────
+    async handleHeartbeat(_req, res) {
+        this.lastHeartbeat = Date.now();
+        this.json(res, {
+            success: true,
+            agentMode: true,
+            devServerRunning: this.devServer.isRunning,
+        });
+    }
+    // ─── /live/hard-patterns ─────────────────────────────────────
+    async handleHardPatterns(_req, res, body) {
+        const data = JSON.parse(body);
+        const { file, code } = data;
+        if (!file || !code) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing file or code' });
+            return;
+        }
+        const errors = await this.checker.validateHardPatterns(file, code);
+        this.json(res, {
+            success: true,
+            errors: errors.map(structuredErrorToString),
+            structuredErrors: errors,
+            errorCount: errors.length,
+            passed: errors.length === 0,
+        });
+    }
+    // ─── /live/hard-patterns-batch ───────────────────────────────
+    async handleHardPatternsBatch(_req, res, body) {
+        const data = JSON.parse(body);
+        const { files } = data; // { "src/App.tsx": "code..." }
+        if (!files || typeof files !== 'object') {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing files object' });
+            return;
+        }
+        const allErrors = [];
+        for (const [filePath, code] of Object.entries(files)) {
+            const errors = await this.checker.validateHardPatterns(filePath, code);
+            allErrors.push(...errors);
+        }
+        this.json(res, {
+            success: true,
+            errors: allErrors.map(structuredErrorToString),
+            structuredErrors: allErrors,
+            errorCount: allErrors.length,
+            passed: allErrors.length === 0,
+        });
+    }
+    // ─── /live/normalize ─────────────────────────────────────────
+    async handleNormalize(_req, res, body) {
+        // In agent mode, normalization is a pass-through — the code is already local.
+        // We run hard pattern validation and type checking.
+        const data = JSON.parse(body);
+        const { file, code } = data;
+        if (!file || code === undefined) {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing file or code' });
+            return;
+        }
+        const hardErrors = await this.checker.validateHardPatterns(file, code);
+        this.json(res, {
+            success: true,
+            code, // Return code as-is (no normalization needed locally)
+            hardErrors: hardErrors.map(structuredErrorToString),
+            tsErrors: [],
+            repairsApplied: false,
+        });
+    }
+    // ─── /live/normalize-batch ───────────────────────────────────
+    async handleNormalizeBatch(_req, res, body) {
+        const data = JSON.parse(body);
+        const { files } = data;
+        if (!files || typeof files !== 'object') {
+            res.statusCode = 400;
+            this.json(res, { error: 'Missing files object' });
+            return;
+        }
+        const results = {};
+        for (const [filePath, code] of Object.entries(files)) {
+            const errors = await this.checker.validateHardPatterns(filePath, code);
+            results[filePath] = {
+                code: code,
+                hardErrors: errors.map(structuredErrorToString),
+            };
+        }
+        this.json(res, { success: true, results });
+    }
+    // ─── /live/invalidate ────────────────────────────────────────
+    async handleInvalidate(_req, res) {
+        // No cache to invalidate locally
+        this.json(res, { success: true, message: 'No-op in agent mode' });
+    }
+    // ─── /live/refetch ───────────────────────────────────────────
+    async handleRefetch(_req, res) {
+        // In agent mode, files are local — no need to refetch from DB
+        this.json(res, { success: true, message: 'Files are local, no refetch needed in agent mode' });
+    }
+    // ─── /live/grace-period ──────────────────────────────────────
+    async handleGracePeriod(_req, res) {
+        // No-op in agent mode
+        this.json(res, { success: true });
+    }
+    // ─── /live/stats ─────────────────────────────────────────────
+    async handleStats(_req, res) {
+        const stats = this.devServer.getStats();
+        this.json(res, {
+            success: true,
+            mode: 'agent',
+            agentMode: true,
+            hostname: os.hostname(),
+            platform: `${os.platform()} ${os.arch()}`,
+            devServerRunning: this.devServer.isRunning,
+            devServerPort: this.options.devPort,
+            uptime: this.devServer.uptime,
+            process: stats,
+            memory: {
+                totalMb: Math.round(os.totalmem() / (1024 * 1024)),
+                freeMb: Math.round(os.freemem() / (1024 * 1024)),
+            },
+        });
+    }
+    // ─── /live/usage ─────────────────────────────────────────────
+    async handleUsage(_req, res) {
+        // Agent mode: usage is free (local machine)
+        this.json(res, {
+            success: true,
+            agentMode: true,
+            usage: {
+                projectId: this.options.projectId,
+                mode: 'agent',
+                seconds: Math.round(this.devServer.uptime / 1000),
+                requests: 0,
+            },
+        });
+    }
+    // ─── /health ─────────────────────────────────────────────────
+    async handleHealth(_req, res) {
+        this.json(res, {
+            status: 'ok',
+            mode: 'agent',
+            agentMode: true,
+            devServer: this.devServer.isRunning,
+            uptime: this.devServer.uptime,
+        });
+    }
+    // ─── Helpers ─────────────────────────────────────────────────
+    json(res, data) {
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.end(JSON.stringify(data));
+    }
+    collectBody(req) {
+        return new Promise((resolve) => {
+            let body = '';
+            req.on('data', (chunk) => { body += chunk.toString(); });
+            req.on('end', () => resolve(body));
+        });
+    }
+}
+//# sourceMappingURL=localServer.js.map

package/dist/packageInstaller.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Package Installer — handles npm/pnpm package installation locally.
+ * Replaces the container-based /live/install endpoint.
+ */
+export interface PackageInstallerOptions {
+    projectDir: string;
+}
+export declare class PackageInstaller {
+    private projectDir;
+    constructor(options: PackageInstallerOptions);
+    /**
+     * Install packages into the project.
+     */
+    install(packages: string[], dev?: boolean): Promise<{
+        success: boolean;
+        output: string;
+        installedPackages: string[];
+    }>;
+    /**
+     * Ensure all project dependencies are installed.
+     */
+    ensureDependencies(): Promise<void>;
+    /**
+     * Detect which package manager is used (pnpm, yarn, npm).
+     */
+    private detectPackageManager;
+    private buildInstallArgs;
+    private runCommand;
+}