nstantpage-agent 0.8.17 → 0.8.18

package/dist/localServer.d.ts

@@ -129,6 +129,16 @@ export declare class LocalServer {
     private handleTree;
     private handleFileContent;
     private handleSaveFile;
+    private static readonly BROWSE_SKIP_DIRS;
+    private static readonly BROWSE_BINARY_EXTS;
+    private collectFilesRecursive;
+    private handleBrowseListFiles;
+    private handleBrowseFile;
+    private handleBrowseTree;
+    private handleBrowseSave;
+    private handleBrowseSearch;
+    private handleBrowseDelete;
+    private matchGlob;
     private handleSetDevPort;
     private handleHealth;
     /**

package/dist/localServer.js

@@ -406,6 +406,13 @@ export class LocalServer {
             '/live/save-file': this.handleSaveFile,
             '/live/set-dev-port': this.handleSetDevPort,
             '/health': this.handleHealth,
+            // ── /browse/* endpoints (same as statusServer, but accessible through tunnel) ──
+            '/browse/list-files': this.handleBrowseListFiles,
+            '/browse/file': this.handleBrowseFile,
+            '/browse/tree': this.handleBrowseTree,
+            '/browse/save': this.handleBrowseSave,
+            '/browse/search': this.handleBrowseSearch,
+            '/browse/delete': this.handleBrowseDelete,
         };
         if (handlers[path])
             return handlers[path];
@@ -1226,6 +1233,199 @@ export class LocalServer {
             this.json(res, { error: error.message }, 500);
         }
     }
+    // ─── /browse/* — Tunnel-accessible file operations ──────────
+    // These mirror the statusServer's /browse/* endpoints but use the
+    // project directory from this LocalServer instance. The backend's
+    // DiskFileService routes through the gateway → tunnel → here.
+    static BROWSE_SKIP_DIRS = new Set([
+        'node_modules', 'dist', '.git', '.vite-cache', '.next',
+        '__pycache__', '.turbo', '.cache', 'build', '.svelte-kit',
+    ]);
+    static BROWSE_BINARY_EXTS = new Set([
+        '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.svg', '.bmp',
+        '.woff', '.woff2', '.ttf', '.eot', '.otf',
+        '.zip', '.tar', '.gz', '.rar', '.7z',
+        '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+        '.mp3', '.mp4', '.wav', '.avi', '.mov',
+        '.exe', '.dll', '.so', '.dylib', '.o',
+    ]);
+    collectFilesRecursive(baseDir, currentDir, out) {
+        let entries;
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') && entry.name !== '.env')
+                continue;
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(baseDir, fullPath);
+            if (entry.isDirectory()) {
+                if (LocalServer.BROWSE_SKIP_DIRS.has(entry.name))
+                    continue;
+                this.collectFilesRecursive(baseDir, fullPath, out);
+            }
+            else {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (LocalServer.BROWSE_BINARY_EXTS.has(ext)) {
+                    out.push({ filePath: relativePath, totalLines: 0 });
+                }
+                else {
+                    try {
+                        const content = fs.readFileSync(fullPath, 'utf-8');
+                        out.push({ filePath: relativePath, totalLines: content.split('\n').length });
+                    }
+                    catch {
+                        out.push({ filePath: relativePath, totalLines: 0 });
+                    }
+                }
+            }
+        }
+    }
+    async handleBrowseListFiles(_req, res) {
+        const dir = this.options.projectDir;
+        try {
+            const files = [];
+            this.collectFilesRecursive(dir, dir, files);
+            this.json(res, { files });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    async handleBrowseFile(_req, res, _body, url) {
+        const filePath = url.searchParams.get('path');
+        if (!filePath) {
+            this.json(res, { error: 'path parameter required' }, 400);
+            return;
+        }
+        const dir = this.options.projectDir;
+        const fullPath = path.resolve(dir, filePath);
+        if (!fullPath.startsWith(path.resolve(dir))) {
+            this.json(res, { error: 'Path traversal not allowed' }, 403);
+            return;
+        }
+        try {
+            if (!fs.existsSync(fullPath)) {
+                this.json(res, { error: 'File not found' }, 404);
+                return;
+            }
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            this.json(res, { content });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    async handleBrowseTree(_req, res) {
+        try {
+            const tree = await this.fileManager.getFileTree();
+            this.json(res, tree);
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    async handleBrowseSave(_req, res, body) {
+        try {
+            const { filePath, content } = JSON.parse(body);
+            if (!filePath || content === undefined) {
+                this.json(res, { error: 'filePath and content required' }, 400);
+                return;
+            }
+            const dir = this.options.projectDir;
+            const fullPath = path.resolve(dir, filePath);
+            if (!fullPath.startsWith(path.resolve(dir))) {
+                this.json(res, { error: 'Path traversal not allowed' }, 403);
+                return;
+            }
+            const parentDir = path.dirname(fullPath);
+            if (!fs.existsSync(parentDir))
+                fs.mkdirSync(parentDir, { recursive: true });
+            fs.writeFileSync(fullPath, content, 'utf-8');
+            this.json(res, { success: true });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    async handleBrowseSearch(_req, res, body) {
+        try {
+            const { query, isRegex, filePattern } = JSON.parse(body);
+            if (!query) {
+                this.json(res, { error: 'query required' }, 400);
+                return;
+            }
+            const dir = this.options.projectDir;
+            const files = [];
+            this.collectFilesRecursive(dir, dir, files);
+            const regex = isRegex ? new RegExp(query, 'gi') : null;
+            const results = [];
+            const maxResults = 100;
+            for (const f of files) {
+                if (results.length >= maxResults)
+                    break;
+                if (filePattern && !this.matchGlob(f.filePath, filePattern))
+                    continue;
+                const fullPath = path.resolve(dir, f.filePath);
+                let fileContent;
+                try {
+                    fileContent = fs.readFileSync(fullPath, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                const lines = fileContent.split('\n');
+                for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+                    const matched = regex ? regex.test(lines[i]) : lines[i].toLowerCase().includes(query.toLowerCase());
+                    if (regex)
+                        regex.lastIndex = 0;
+                    if (matched) {
+                        results.push({ filePath: f.filePath, line: i + 1, content: lines[i] });
+                    }
+                }
+            }
+            this.json(res, { results });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    async handleBrowseDelete(_req, res, body) {
+        try {
+            const { filePath } = JSON.parse(body);
+            if (!filePath) {
+                this.json(res, { error: 'filePath required' }, 400);
+                return;
+            }
+            const dir = this.options.projectDir;
+            const fullPath = path.resolve(dir, filePath);
+            if (!fullPath.startsWith(path.resolve(dir))) {
+                this.json(res, { error: 'Path traversal not allowed' }, 403);
+                return;
+            }
+            if (!fs.existsSync(fullPath)) {
+                this.json(res, { error: 'File not found' }, 404);
+                return;
+            }
+            fs.unlinkSync(fullPath);
+            this.json(res, { success: true });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    matchGlob(filePath, pattern) {
+        const regexPattern = '^' + pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '<<<GLOBSTAR>>>')
+            .replace(/\*/g, '[^/]*')
+            .replace(/<<<GLOBSTAR>>>/g, '.*')
+            .replace(/\?/g, '.') + '$';
+        return new RegExp(regexPattern, 'i').test(filePath);
+    }
     // ─── /live/set-dev-port ─────────────────────────────────────
     async handleSetDevPort(_req, res, body) {
         try {

package/dist/tunnel.js

@@ -503,7 +503,7 @@ export class TunnelClient {
      */
     handleHttpRequest(request) {
         const { url, headers } = request;
-        const isApiRequest = url.startsWith('/live/') || url === '/health';
+        const isApiRequest = url.startsWith('/live/') || url.startsWith('/browse/') || url === '/health';
         // Use x-target-port header if present (multi-port tunneling), else fall back to default
         const portHeader = headers?.['x-target-port'];
         const overridePort = portHeader ? parseInt(String(portHeader), 10) : NaN;

package/package.json

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