nstantpage-agent 0.8.17 → 0.8.19

package/dist/commands/sync.d.ts

@@ -1,15 +1,14 @@
 /**
- * Sync command — push local files to nstantpage DB and start the agent.
+ * Sync command — link a local directory to an nstantpage project.
  *
  * Usage:
- *   nstantpage sync              — Sync current directory to nstantpage, then start agent
- *   nstantpage sync /path/to/dir — Sync a specific directory
+ *   nstantpage sync              — Link current directory to nstantpage project
+ *   nstantpage sync /path/to/dir — Link 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`)
+ * 1. Creates a LocalRepo project if one doesn't exist (name = folder name)
+ * 2. Links the project to this device (deviceId + deviceName)
+ * 3. Files stay on disk — no file pushing to the DB
  */
 interface SyncOptions {
     local?: boolean | string;

package/dist/commands/sync.js

@@ -1,41 +1,20 @@
 /**
- * Sync command — push local files to nstantpage DB and start the agent.
+ * Sync command — link a local directory to an nstantpage project.
  *
  * Usage:
- *   nstantpage sync              — Sync current directory to nstantpage, then start agent
- *   nstantpage sync /path/to/dir — Sync a specific directory
+ *   nstantpage sync              — Link current directory to nstantpage project
+ *   nstantpage sync /path/to/dir — Link 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`)
+ * 1. Creates a LocalRepo project if one doesn't exist (name = folder name)
+ * 2. Links the project to this device (deviceId + deviceName)
+ * 3. Files stay on disk — no file pushing to the DB
  */
 import chalk from 'chalk';
+import os from 'os';
 import path from 'path';
 import fs from 'fs';
 import { getConfig, getDeviceId } from '../config.js';
-const SKIP_DIRS = new Set([
-    'node_modules', 'dist', '.git', '.vite-cache', '.next',
-    '__pycache__', '.turbo', '.cache', 'build', 'out',
-    '.svelte-kit', '.nuxt', '.output', '.vercel',
-    '.angular', '.parcel-cache', '.rollup.cache',
-]);
-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).
  */
@@ -45,51 +24,6 @@ function resolveBackendUrl(gateway, backend) {
     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
@@ -117,26 +51,19 @@ export async function syncCommand(directory, options) {
     }
     const backendUrl = resolveBackendUrl(gateway, options.backend);
     const deviceId = getDeviceId();
+    const deviceName = os.hostname();
     const folderName = path.basename(projectDir);
     console.log(chalk.blue(`\n  📂 nstantpage sync\n`));
     console.log(chalk.gray(`  Directory:  ${projectDir}`));
+    console.log(chalk.gray(`  Device:     ${deviceName}`));
     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
+    // 1. 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'));
-                // .NET uses full claim type URIs; also check standard 'sub' claim
                 userId = payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier']
                     || payload['sub']
                     || payload['nameid'];
@@ -144,8 +71,8 @@ export async function syncCommand(directory, options) {
         }
         catch { }
     }
-    // 3. Create or find LocalRepo project
-    console.log(chalk.gray('  Creating project...'));
+    // 2. Create or find LocalRepo project (linked to this device)
+    console.log(chalk.gray('  Linking project...'));
     let projectId;
     try {
         const createRes = await fetch(`${backendUrl}/api/projects`, {
@@ -160,6 +87,7 @@ export async function syncCommand(directory, options) {
                 localFolderPath: projectDir,
                 userId,
                 deviceId,
+                deviceName,
             }),
         });
         if (!createRes.ok) {
@@ -174,68 +102,7 @@ export async function syncCommand(directory, options) {
         console.log(chalk.red(`  ✗ ${err.message}`));
         process.exit(1);
     }
-    // 4. Create new version and clear old files (clean sync)
-    console.log(chalk.gray('  Creating new version (clearing old files)...'));
-    try {
-        const syncRes = await fetch(`${backendUrl}/api/projects/${projectId}/sync`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Content-Type': 'application/json',
-            },
-        });
-        if (!syncRes.ok) {
-            const text = await syncRes.text().catch(() => '');
-            throw new Error(`Sync init failed (${syncRes.status}): ${text}`);
-        }
-        const syncData = await syncRes.json();
-        console.log(chalk.green(`  ✓ Version ${syncData.versionNumber} created (old files cleared)`));
-    }
-    catch (err) {
-        console.log(chalk.red(`  ✗ ${err.message}`));
-        process.exit(1);
-    }
-    // 5. 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`));
-    console.log(chalk.blue(`\n  ✓ Sync complete! Project ID: ${projectId}`));
+    console.log(chalk.blue(`\n  ✓ Project linked to device "${deviceName}"! Project ID: ${projectId}`));
     console.log(chalk.gray(`\n  View on web:  https://nstantpage.com/project/${projectId}`));
     console.log(chalk.gray(`  Start agent:  nstantpage start --project-id ${projectId} --dir "${projectDir}"\n`));
 }

package/dist/fileManager.d.ts

@@ -40,7 +40,7 @@ export declare class FileManager {
      * Build a recursive file tree of the project directory.
      * Returns a structure matching the backend's /api/projects/{id}/tree format.
      */
-    getFileTree(): Promise<{
+    getFileTree(showHidden?: boolean): Promise<{
         name: string;
         path: string;
         isDirectory: boolean;

package/dist/fileManager.js

@@ -105,7 +105,7 @@ export class FileManager {
      * Build a recursive file tree of the project directory.
      * Returns a structure matching the backend's /api/projects/{id}/tree format.
      */
-    async getFileTree() {
+    async getFileTree(showHidden = false) {
         const root = {
             name: path.basename(this.projectDir),
             path: '',
@@ -113,11 +113,11 @@ export class FileManager {
             children: [],
         };
         if (existsSync(this.projectDir)) {
-            root.children = await this.buildTree(this.projectDir, '');
+            root.children = await this.buildTree(this.projectDir, '', showHidden);
         }
         return root;
     }
-    async buildTree(dir, relativePath) {
+    async buildTree(dir, relativePath, showHidden = false) {
         const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', '.vite-cache', '.next', '__pycache__', '.turbo', '.cache']);
         const entries = await fs.readdir(dir, { withFileTypes: true });
         const result = [];
@@ -130,13 +130,13 @@ export class FileManager {
             return a.name.localeCompare(b.name);
         });
         for (const entry of sorted) {
-            if (entry.name.startsWith('.') && entry.name !== '.env')
+            if (!showHidden && entry.name.startsWith('.') && entry.name !== '.env')
                 continue;
             const entryRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
             if (entry.isDirectory()) {
-                if (SKIP_DIRS.has(entry.name))
+                if (!showHidden && SKIP_DIRS.has(entry.name))
                     continue;
-                const children = await this.buildTree(path.join(dir, entry.name), entryRelPath);
+                const children = await this.buildTree(path.join(dir, entry.name), entryRelPath, showHidden);
                 result.push({ name: entry.name, path: entryRelPath, isDirectory: true, children });
             }
             else {

package/dist/localServer.d.ts

@@ -104,6 +104,12 @@ export declare class LocalServer {
     private handleExec;
     private handleTerminal;
     private handleTerminalSessions;
+    private handleTerminalDestroy;
+    private handleTerminalDestroyAll;
+    /**
+     * Force-kill a terminal session: send signals, notify listeners, remove from map.
+     */
+    private killSession;
     private handleTerminalWrite;
     private handleTerminalResize;
     private handleAgentStatus;
@@ -129,6 +135,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

@@ -375,6 +375,8 @@ export class LocalServer {
             '/live/terminal/sessions': this.handleTerminalSessions,
             '/live/terminal/write': this.handleTerminalWrite,
             '/live/terminal/resize': this.handleTerminalResize,
+            '/live/terminal/destroy': this.handleTerminalDestroy,
+            '/live/terminal/destroy-all': this.handleTerminalDestroyAll,
             '/live/agent-status': this.handleAgentStatus,
             '/live/container-status': this.handleContainerStatus,
             '/live/container-stats': this.handleContainerStats,
@@ -406,15 +408,27 @@ 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];
-        // Prefix matches (e.g., /live/errors/123, /live/logs/123)
+        // Prefix matches — find the LONGEST matching prefix (e.g., /live/terminal/sessions
+        // must not match /live/terminal when /live/terminal/sessions is available)
+        let bestMatch = null;
+        let bestLen = 0;
         for (const [route, handler] of Object.entries(handlers)) {
-            if (path.startsWith(route + '/'))
-                return handler;
+            if (path.startsWith(route + '/') && route.length > bestLen) {
+                bestMatch = handler;
+                bestLen = route.length;
+            }
         }
-        return null;
+        return bestMatch;
     }
     // ─── /live/sync ──────────────────────────────────────────────
     async handleSync(_req, res, body) {
@@ -584,6 +598,24 @@ export class LocalServer {
                 cols: s.cols,
                 rows: s.rows,
             }));
+            // Include dev server process as a virtual session entry
+            if (this.devServer.isRunning) {
+                const stats = this.devServer.getStats();
+                sessions.unshift({
+                    id: `devserver-${this.options.projectId}`,
+                    projectId: this.options.projectId,
+                    isAiSession: false,
+                    label: 'Dev Server',
+                    createdAt: Date.now() - this.devServer.uptime,
+                    lastActivity: Date.now(),
+                    exited: false,
+                    exitCode: null,
+                    devServerReady: true,
+                    devServerPort: this.devServer.port,
+                    pid: stats.pid,
+                    isDevServer: true,
+                });
+            }
             this.json(res, { success: true, sessions });
             return;
         }
@@ -779,6 +811,78 @@ export class LocalServer {
             },
         });
     }
+    // ─── /live/terminal/destroy ──────────────────────────────────
+    async handleTerminalDestroy(_req, res, body) {
+        let parsed = {};
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch { }
+        const { sessionId } = parsed;
+        if (!sessionId) {
+            res.statusCode = 400;
+            this.json(res, { success: false, error: 'sessionId required' });
+            return;
+        }
+        // Handle dev server virtual session
+        if (sessionId.startsWith('devserver-')) {
+            await this.devServer.stop();
+            this.json(res, { success: true });
+            return;
+        }
+        const session = terminalSessions.get(sessionId);
+        if (!session) {
+            // Already gone — treat as success
+            this.json(res, { success: true });
+            return;
+        }
+        this.killSession(sessionId, session);
+        this.json(res, { success: true });
+    }
+    // ─── /live/terminal/destroy-all ──────────────────────────────
+    async handleTerminalDestroyAll(_req, res) {
+        let count = 0;
+        for (const [sessionId, session] of Array.from(terminalSessions.entries())) {
+            this.killSession(sessionId, session);
+            count++;
+        }
+        // Also stop the dev server
+        if (this.devServer.isRunning) {
+            await this.devServer.stop();
+            count++;
+        }
+        this.json(res, { success: true, destroyed: count });
+    }
+    /**
+     * Force-kill a terminal session: send signals, notify listeners, remove from map.
+     */
+    killSession(sessionId, session) {
+        if (!session.exited) {
+            if (session.ptyProcess) {
+                try {
+                    session.ptyProcess.kill();
+                }
+                catch { }
+            }
+            else if (session.shell) {
+                try {
+                    session.shell.kill('SIGKILL');
+                }
+                catch { }
+            }
+        }
+        session.exited = true;
+        session.exitCode = null;
+        for (const listener of session.exitListeners) {
+            try {
+                listener(null);
+            }
+            catch { }
+        }
+        session.dataListeners.clear();
+        session.exitListeners.clear();
+        terminalSessions.delete(sessionId);
+    }
     // ─── /live/terminal/write ────────────────────────────────────
     async handleTerminalWrite(_req, res, body) {
         let parsed = {};
@@ -1183,9 +1287,10 @@ export class LocalServer {
         }
     }
     // ─── /live/tree ──────────────────────────────────────────────
-    async handleTree(_req, res) {
+    async handleTree(_req, res, _body, url) {
         try {
-            const tree = await this.fileManager.getFileTree();
+            const showHidden = url.searchParams.get('showHidden') === 'true';
+            const tree = await this.fileManager.getFileTree(showHidden);
             this.json(res, tree);
         }
         catch (error) {
@@ -1226,6 +1331,200 @@ 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, _body, url) {
+        try {
+            const showHidden = url.searchParams.get('showHidden') === 'true';
+            const tree = await this.fileManager.getFileTree(showHidden);
+            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.19",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {