nstantpage-agent 0.2.0

package/dist/errorStore.js

@@ -0,0 +1,167 @@
+/**
+ * Error Store — tracks build, type, lint, and runtime errors for a project.
+ * This replaces the container-based error tracking from the gateway.
+ */
+export class ErrorStore {
+    buildErrors = [];
+    typeErrors = [];
+    lintErrors = [];
+    runtimeErrors = [];
+    setBuildErrors(errors) {
+        this.buildErrors = errors;
+    }
+    setTypeErrors(errors) {
+        this.typeErrors = errors;
+    }
+    setLintErrors(errors) {
+        this.lintErrors = errors;
+    }
+    addRuntimeError(error) {
+        // Dedup by signature
+        if (!this.runtimeErrors.some(e => e.signature === error.signature)) {
+            this.runtimeErrors.push(error);
+            // Keep max 50 runtime errors
+            if (this.runtimeErrors.length > 50) {
+                this.runtimeErrors = this.runtimeErrors.slice(-50);
+            }
+        }
+    }
+    clearRuntimeErrors() {
+        this.runtimeErrors = [];
+    }
+    clearAll() {
+        this.buildErrors = [];
+        this.typeErrors = [];
+        this.lintErrors = [];
+        this.runtimeErrors = [];
+    }
+    getAllErrors() {
+        const all = [
+            ...this.buildErrors,
+            ...this.typeErrors,
+            ...this.lintErrors,
+            ...this.runtimeErrors,
+        ];
+        // Deduplicate by signature
+        const seen = new Set();
+        return all.filter(e => {
+            if (seen.has(e.signature))
+                return false;
+            seen.add(e.signature);
+            return true;
+        });
+    }
+    getErrorsByType() {
+        return {
+            buildErrors: this.buildErrors.map(structuredErrorToString),
+            typeErrors: this.typeErrors.map(structuredErrorToString),
+            lintErrors: this.lintErrors.map(structuredErrorToString),
+            runtimeErrors: this.runtimeErrors.map(structuredErrorToString),
+        };
+    }
+    getStructuredByType() {
+        return {
+            buildErrors: [...this.buildErrors],
+            typeErrors: [...this.typeErrors],
+            lintErrors: [...this.lintErrors],
+            runtimeErrors: [...this.runtimeErrors],
+        };
+    }
+}
+/**
+ * Convert structured error to display string.
+ */
+export function structuredErrorToString(error) {
+    if (error.file && error.line) {
+        const prefix = error.type === 'type' ? '[TS]' :
+            error.type === 'lint' ? '[Lint]' :
+                error.type === 'hard' ? '[HARD]' :
+                    error.type === 'runtime' ? '[Runtime]' : '';
+        const codeStr = error.code ? ` ${error.code}:` : '';
+        return `${prefix ? prefix + ' ' : ''}${error.file} (Line ${error.line}):${codeStr} ${error.message}`;
+    }
+    return error.message;
+}
+/**
+ * Parse a raw error string into a structured error.
+ */
+export function parseErrorString(errorStr, defaultType = 'build') {
+    let file;
+    let line;
+    let col;
+    let message = errorStr;
+    let type = defaultType;
+    let code;
+    // Strip ANSI codes
+    // eslint-disable-next-line no-control-regex
+    const cleanStr = errorStr.replace(/\u001b\[[0-9;]*m/g, '').trim();
+    // Pattern 1: [TYPE] file (Line N): message
+    const prefixMatch = cleanStr.match(/^\[(TS|Lint|HARD|Build|Runtime)\]\s*(.+?)\s*\(Line\s*(\d+)\):\s*(.+)$/i);
+    if (prefixMatch) {
+        const typeStr = prefixMatch[1].toLowerCase();
+        if (typeStr === 'ts')
+            type = 'type';
+        else if (typeStr === 'lint')
+            type = 'lint';
+        else if (typeStr === 'hard')
+            type = 'hard';
+        else if (typeStr === 'runtime')
+            type = 'runtime';
+        else
+            type = 'build';
+        file = prefixMatch[2];
+        line = parseInt(prefixMatch[3], 10);
+        message = prefixMatch[4];
+        const codeMatch = message.match(/\s*\[([^\]]+)\]$/);
+        if (codeMatch) {
+            code = codeMatch[1];
+            message = message.replace(/\s*\[[^\]]+\]$/, '');
+        }
+    }
+    // Pattern 2: file(line,col): error CODE: message
+    else {
+        const tscMatch = cleanStr.match(/^(.+?)\((\d+),(\d+)\):\s*(?:error|warning)\s+(TS\d+):\s*(.+)$/);
+        if (tscMatch) {
+            file = tscMatch[1];
+            line = parseInt(tscMatch[2], 10);
+            col = parseInt(tscMatch[3], 10);
+            code = tscMatch[4];
+            message = tscMatch[5];
+            type = 'type';
+        }
+        // Pattern 3: file:line:col: message
+        else {
+            const colonMatch = cleanStr.match(/^(.+?):(\d+):(\d+):\s*(.+)$/);
+            if (colonMatch) {
+                file = colonMatch[1];
+                line = parseInt(colonMatch[2], 10);
+                col = parseInt(colonMatch[3], 10);
+                message = colonMatch[4];
+            }
+        }
+    }
+    // Normalize file path to project-relative
+    if (file) {
+        file = file.replace(/^\.\//, '').replace(/^\//, '');
+        const srcIdx = file.indexOf('src/');
+        if (srcIdx > 0)
+            file = file.substring(srcIdx);
+    }
+    const signature = `${type}:${file || 'unknown'}:${line || 0}:${message.substring(0, 100)}`;
+    return { file, line, col, message: message.trim(), type, code, signature, raw: errorStr };
+}
+/**
+ * Filter non-error messages (Babel notes, CSS at-rule warnings, etc.)
+ */
+export function filterNonErrors(errors) {
+    return errors.filter(error => {
+        if (/\[BABEL\]\s*Note:/i.test(error))
+            return false;
+        if (error.includes('node_modules/@babel/parser/src/parser/statement.ts'))
+            return false;
+        if (error.includes('at-rule-no-unknown'))
+            return false;
+        return true;
+    });
+}
+//# sourceMappingURL=errorStore.js.map

package/dist/fileManager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * File Manager — handles file I/O for the local project.
+ * Replaces the gateway's projectManager.writeFiles + docker cp workflow.
+ */
+export interface FileManagerOptions {
+    projectDir: string;
+}
+export declare class FileManager {
+    private projectDir;
+    constructor(options: FileManagerOptions);
+    /**
+     * Write multiple files to the project directory.
+     * files: { "src/App.tsx": "content...", "src/utils.ts": "content..." }
+     */
+    writeFiles(files: Record<string, string>): Promise<{
+        filesWritten: number;
+        paths: string[];
+    }>;
+    /**
+     * Delete files from the project directory.
+     */
+    deleteFiles(filePaths: string[]): Promise<number>;
+    /**
+     * Read a file from the project directory.
+     */
+    readFile(filePath: string): Promise<string | null>;
+    /**
+     * List all source files in the project (src/ directory).
+     */
+    listSourceFiles(): Promise<string[]>;
+    /**
+     * Check if the project has a backend (server/ directory).
+     */
+    hasBackend(): boolean;
+    /**
+     * Get the project directory path.
+     */
+    getProjectDir(): string;
+    /**
+     * Check if a path exists.
+     */
+    exists(relativePath: string): boolean;
+    private walkDir;
+}

package/dist/fileManager.js

@@ -0,0 +1,129 @@
+/**
+ * File Manager — handles file I/O for the local project.
+ * Replaces the gateway's projectManager.writeFiles + docker cp workflow.
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+export class FileManager {
+    projectDir;
+    constructor(options) {
+        this.projectDir = options.projectDir;
+    }
+    /**
+     * Write multiple files to the project directory.
+     * files: { "src/App.tsx": "content...", "src/utils.ts": "content..." }
+     */
+    async writeFiles(files) {
+        let filesWritten = 0;
+        const paths = [];
+        for (const [filePath, content] of Object.entries(files)) {
+            try {
+                // Sanitize path — prevent directory traversal
+                const normalized = path.normalize(filePath).replace(/\.\.\//g, '');
+                const fullPath = path.join(this.projectDir, normalized);
+                // Security check
+                if (!fullPath.startsWith(this.projectDir)) {
+                    console.warn(`  [FileManager] Blocked path traversal: ${filePath}`);
+                    continue;
+                }
+                // Ensure directory exists
+                await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                // Write file
+                await fs.writeFile(fullPath, content, 'utf-8');
+                filesWritten++;
+                paths.push(normalized);
+            }
+            catch (err) {
+                console.error(`  [FileManager] Failed to write ${filePath}: ${err.message}`);
+            }
+        }
+        return { filesWritten, paths };
+    }
+    /**
+     * Delete files from the project directory.
+     */
+    async deleteFiles(filePaths) {
+        let filesDeleted = 0;
+        for (const filePath of filePaths) {
+            try {
+                const normalized = path.normalize(filePath).replace(/\.\.\//g, '');
+                const fullPath = path.join(this.projectDir, normalized);
+                if (!fullPath.startsWith(this.projectDir))
+                    continue;
+                await fs.unlink(fullPath);
+                filesDeleted++;
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    console.error(`  [FileManager] Failed to delete ${filePath}: ${err.message}`);
+                }
+            }
+        }
+        return filesDeleted;
+    }
+    /**
+     * Read a file from the project directory.
+     */
+    async readFile(filePath) {
+        try {
+            const normalized = path.normalize(filePath).replace(/\.\.\//g, '');
+            const fullPath = path.join(this.projectDir, normalized);
+            if (!fullPath.startsWith(this.projectDir))
+                return null;
+            return await fs.readFile(fullPath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all source files in the project (src/ directory).
+     */
+    async listSourceFiles() {
+        const srcDir = path.join(this.projectDir, 'src');
+        if (!existsSync(srcDir))
+            return [];
+        const files = [];
+        await this.walkDir(srcDir, files);
+        return files.map(f => path.relative(this.projectDir, f));
+    }
+    /**
+     * Check if the project has a backend (server/ directory).
+     */
+    hasBackend() {
+        return existsSync(path.join(this.projectDir, 'server', 'index.ts')) ||
+            existsSync(path.join(this.projectDir, 'server', 'index.js'));
+    }
+    /**
+     * Get the project directory path.
+     */
+    getProjectDir() {
+        return this.projectDir;
+    }
+    /**
+     * Check if a path exists.
+     */
+    exists(relativePath) {
+        return existsSync(path.join(this.projectDir, relativePath));
+    }
+    async walkDir(dir, files) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip node_modules, dist, .git
+                if (['node_modules', 'dist', '.git', '.vite-cache'].includes(entry.name))
+                    continue;
+                await this.walkDir(fullPath, files);
+            }
+            else {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (['.ts', '.tsx', '.js', '.jsx', '.css', '.scss', '.json', '.html'].includes(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=fileManager.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { TunnelClient } from './tunnel.js';
+export { LocalServer } from './localServer.js';
+export { DevServer } from './devServer.js';
+export { FileManager } from './fileManager.js';
+export { Checker } from './checker.js';
+export { ErrorStore } from './errorStore.js';
+export { PackageInstaller } from './packageInstaller.js';
+export { getConfig } from './config.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { TunnelClient } from './tunnel.js';
+export { LocalServer } from './localServer.js';
+export { DevServer } from './devServer.js';
+export { FileManager } from './fileManager.js';
+export { Checker } from './checker.js';
+export { ErrorStore } from './errorStore.js';
+export { PackageInstaller } from './packageInstaller.js';
+export { getConfig } from './config.js';
+//# sourceMappingURL=index.js.map

package/dist/localServer.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { DevServer } from './devServer.js';
+export interface LocalServerOptions {
+    projectDir: string;
+    projectId: string;
+    apiPort: number;
+    devPort: number;
+    env?: Record<string, string>;
+}
+export declare class LocalServer {
+    private server;
+    private options;
+    private devServer;
+    private fileManager;
+    private checker;
+    private errorStore;
+    private packageInstaller;
+    private lastHeartbeat;
+    constructor(options: LocalServerOptions);
+    getDevServer(): DevServer;
+    getApiPort(): number;
+    getDevPort(): number;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private getHandler;
+    private handleSync;
+    private handleFiles;
+    private handleCheck;
+    private handleErrors;
+    private handleReload;
+    private handleRuntimeError;
+    private handleInstall;
+    private handleExec;
+    private handleTerminal;
+    private handleContainerStatus;
+    private handleContainerStats;
+    private handleLogs;
+    private handleDev;
+    private handleDevRestart;
+    private handleDevStop;
+    private handleOpen;
+    private handleClose;
+    private handleHeartbeat;
+    private handleHardPatterns;
+    private handleHardPatternsBatch;
+    private handleNormalize;
+    private handleNormalizeBatch;
+    private handleInvalidate;
+    private handleRefetch;
+    private handleGracePeriod;
+    private handleStats;
+    private handleUsage;
+    private handleHealth;
+    private json;
+    private collectBody;
+}