nstantpage-agent 0.5.34 → 0.6.0

package/dist/cli.bundle.js

@@ -24426,6 +24426,48 @@ var FileManager = class {
   getProjectDir() {
     return this.projectDir;
   }
+  /**
+   * Build a recursive file tree of the project directory.
+   * Returns a structure matching the backend's /api/projects/{id}/tree format.
+   */
+  async getFileTree() {
+    const root = {
+      name: path8.basename(this.projectDir),
+      path: "",
+      isDirectory: true,
+      children: []
+    };
+    if (existsSync(this.projectDir)) {
+      root.children = await this.buildTree(this.projectDir, "");
+    }
+    return root;
+  }
+  async buildTree(dir, relativePath) {
+    const SKIP_DIRS3 = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".vite-cache", ".next", "__pycache__", ".turbo", ".cache"]);
+    const entries = await fs10.readdir(dir, { withFileTypes: true });
+    const result = [];
+    const sorted = entries.sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory())
+        return -1;
+      if (!a.isDirectory() && b.isDirectory())
+        return 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (const entry of sorted) {
+      if (entry.name.startsWith(".") && entry.name !== ".env")
+        continue;
+      const entryRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS3.has(entry.name))
+          continue;
+        const children = await this.buildTree(path8.join(dir, entry.name), entryRelPath);
+        result.push({ name: entry.name, path: entryRelPath, isDirectory: true, children });
+      } else {
+        result.push({ name: entry.name, path: entryRelPath, isDirectory: false, children: [] });
+      }
+    }
+    return result;
+  }
   /**
    * Check if a path exists.
    */
@@ -26033,6 +26075,9 @@ Access-Control-Allow-Origin: *\r
       "/live/push-to-backend": this.handlePushToBackend,
       "/live/pull-from-backend": this.handlePullFromBackend,
       "/live/disk-file": this.handleDiskFile,
+      "/live/tree": this.handleTree,
+      "/live/file-content": this.handleFileContent,
+      "/live/save-file": this.handleSaveFile,
       "/health": this.handleHealth
     };
     if (handlers[path17])
@@ -26834,6 +26879,47 @@ Access-Control-Allow-Origin: *\r
       this.json(res, { success: false, error: error.message }, 500);
     }
   }
+  // ─── /live/tree ──────────────────────────────────────────────
+  async handleTree(_req, res) {
+    try {
+      const tree = await this.fileManager.getFileTree();
+      this.json(res, tree);
+    } catch (error) {
+      this.json(res, { error: error.message }, 500);
+    }
+  }
+  // ─── /live/file-content ──────────────────────────────────────
+  async handleFileContent(_req, res, _body, url) {
+    const filePath = url.searchParams.get("path");
+    if (!filePath) {
+      this.json(res, { error: "Missing path parameter" }, 400);
+      return;
+    }
+    try {
+      const content = await this.fileManager.readFile(filePath);
+      if (content === null) {
+        this.json(res, { error: "File not found" }, 404);
+        return;
+      }
+      this.json(res, { content });
+    } catch (error) {
+      this.json(res, { error: error.message }, 500);
+    }
+  }
+  // ─── /live/save-file ────────────────────────────────────────
+  async handleSaveFile(_req, res, body) {
+    try {
+      const { filePath, content } = JSON.parse(body);
+      if (!filePath || content === void 0) {
+        this.json(res, { error: "filePath and content required" }, 400);
+        return;
+      }
+      await this.fileManager.writeFiles({ [filePath]: content });
+      this.json(res, { success: true, message: "File saved" });
+    } catch (error) {
+      this.json(res, { error: error.message }, 500);
+    }
+  }
   // ─── /health ─────────────────────────────────────────────────
   async handleHealth(_req, res) {
     this.json(res, {
@@ -27583,6 +27669,7 @@ var StatusServer = class {
       this.server = http5.createServer((req, res) => {
         res.setHeader("Access-Control-Allow-Origin", "*");
         res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
         res.setHeader("Content-Type", "application/json");
         if (req.method === "OPTIONS") {
           res.writeHead(204);
@@ -27642,6 +27729,85 @@ var StatusServer = class {
           });
           return;
         }
+        const parsedUrl = new URL(req.url || "/", `http://localhost:${STATUS_PORT}`);
+        if (req.method === "GET" && url === "/browse/tree") {
+          const dir = parsedUrl.searchParams.get("dir");
+          if (!dir || !fs15.existsSync(dir)) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Missing or invalid dir parameter" }));
+            return;
+          }
+          try {
+            const tree = buildFileTree(dir, path14.basename(dir));
+            res.writeHead(200);
+            res.end(JSON.stringify(tree));
+          } catch (err) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: err.message }));
+          }
+          return;
+        }
+        if (req.method === "GET" && url === "/browse/file") {
+          const dir = parsedUrl.searchParams.get("dir");
+          const filePath = parsedUrl.searchParams.get("path");
+          if (!dir || !filePath) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "dir and path parameters required" }));
+            return;
+          }
+          const fullPath = path14.resolve(dir, filePath);
+          if (!fullPath.startsWith(path14.resolve(dir))) {
+            res.writeHead(403);
+            res.end(JSON.stringify({ error: "Path traversal not allowed" }));
+            return;
+          }
+          try {
+            if (!fs15.existsSync(fullPath)) {
+              res.writeHead(404);
+              res.end(JSON.stringify({ error: "File not found" }));
+              return;
+            }
+            const content = fs15.readFileSync(fullPath, "utf-8");
+            res.writeHead(200);
+            res.end(JSON.stringify({ content }));
+          } catch (err) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: err.message }));
+          }
+          return;
+        }
+        if (req.method === "POST" && url === "/browse/save") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const { dir, filePath, content } = JSON.parse(body);
+              if (!dir || !filePath || content === void 0) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "dir, filePath, and content required" }));
+                return;
+              }
+              const fullPath = path14.resolve(dir, filePath);
+              if (!fullPath.startsWith(path14.resolve(dir))) {
+                res.writeHead(403);
+                res.end(JSON.stringify({ error: "Path traversal not allowed" }));
+                return;
+              }
+              const parentDir = path14.dirname(fullPath);
+              if (!fs15.existsSync(parentDir))
+                fs15.mkdirSync(parentDir, { recursive: true });
+              fs15.writeFileSync(fullPath, content, "utf-8");
+              res.writeHead(200);
+              res.end(JSON.stringify({ success: true }));
+            } catch (err) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          });
+          return;
+        }
         res.writeHead(404);
         res.end(JSON.stringify({ error: "Not found" }));
       });
@@ -27681,6 +27847,45 @@ var StatusServer = class {
     }, null, 2), "utf-8");
   }
 };
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".vite-cache",
+  ".next",
+  "__pycache__",
+  ".turbo",
+  ".cache",
+  "build",
+  ".svelte-kit"
+]);
+function buildFileTree(dirPath, name, relativePath = "") {
+  const node = { name, path: relativePath, isDirectory: true, children: [] };
+  let entries;
+  try {
+    entries = fs15.readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return node;
+  }
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".env")
+      continue;
+    const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name))
+        continue;
+      dirs.push(buildFileTree(path14.join(dirPath, entry.name), entry.name, childRelative));
+    } else {
+      files.push({ name: entry.name, path: childRelative, isDirectory: false, children: [] });
+    }
+  }
+  dirs.sort((a, b) => a.name.localeCompare(b.name));
+  files.sort((a, b) => a.name.localeCompare(b.name));
+  node.children = [...dirs, ...files];
+  return node;
+}
 
 // dist/commands/start.js
 var VERSION = "0.5.29";
@@ -27786,6 +27991,11 @@ function cleanupPreviousAgent(projectId, apiPort, devPort) {
     killPort(apiPort);
   if (devPort !== oldDevPort)
     killPort(devPort);
+  const backendPort = devPort + 1001;
+  killPort(backendPort);
+  const oldBackendPort = oldDevPort ? oldDevPort + 1001 : 0;
+  if (oldBackendPort && oldBackendPort !== backendPort)
+    killPort(oldBackendPort);
   clearProjectConfig(projectId);
 }
 async function startCommand(directory, options) {

package/dist/cli.js

@@ -21,11 +21,13 @@ import { logoutCommand } from './commands/logout.js';
 import { startCommand } from './commands/start.js';
 import { statusCommand } from './commands/status.js';
 import { serviceInstallCommand, serviceUninstallCommand, serviceStatusCommand, serviceStartCommand, serviceStopCommand } from './commands/service.js';
+import { updateCommand } from './commands/update.js';
+import { getPackageVersion } from './version.js';
 const program = new Command();
 program
     .name('nstantpage')
     .description('Local development agent for nstantpage.com — run projects on your machine, preview in the cloud')
-    .version('0.5.29');
+    .version(getPackageVersion());
 program
     .command('login')
     .description('Authenticate with nstantpage.com')
@@ -102,5 +104,11 @@ service
     .command('status')
     .description('Check if the background service is running')
     .action(serviceStatusCommand);
+program
+    .command('update')
+    .description('Update CLI and desktop app to the latest version')
+    .option('--cli', 'Update only the CLI package')
+    .option('--desktop', 'Update only the desktop app')
+    .action(updateCommand);
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/commands/service.js

@@ -130,7 +130,7 @@ export async function serviceInstallCommand(options = {}) {
     }
     // Fallback: headless service (no tray icon)
     if (electronAppPath === null) {
-        console.log(chalk.gray('  Tip: Install the nstantpage desktop app for a system tray icon.'));
+        console.log(chalk.gray('  Tip: Run "nstantpage update --desktop" to download the desktop app with tray icon.'));
     }
     if (platform === 'darwin') {
         await installLaunchd(gateway, token);
@@ -234,6 +234,8 @@ function findElectronApp() {
     if (platform === 'darwin') {
         // Check common macOS install paths
         const candidates = [
+            // Downloaded by postinstall (npm i -g nstantpage-agent)
+            path.join(os.homedir(), '.nstantpage', 'desktop', 'nstantpage.app'),
             '/Applications/nstantpage.app',
             path.join(os.homedir(), 'Applications', 'nstantpage.app'),
             // Dev build location (from electron-builder --dir)
@@ -247,6 +249,8 @@ function findElectronApp() {
     }
     else if (platform === 'win32') {
         const candidates = [
+            // Downloaded by postinstall (npm i -g nstantpage-agent)
+            path.join(os.homedir(), '.nstantpage', 'desktop', 'nstantpage.exe'),
             path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'nstantpage', 'nstantpage.exe'),
             path.join('C:\\Program Files', 'nstantpage', 'nstantpage.exe'),
         ];

package/dist/commands/start.js

@@ -26,7 +26,8 @@ import { LocalServer } from '../localServer.js';
 import { PackageInstaller } from '../packageInstaller.js';
 import { probeLocalPostgres, ensureLocalProjectDb, closeAdminPool, writeDatabaseUrlToEnv } from '../projectDb.js';
 import { StatusServer } from '../statusServer.js';
-const VERSION = '0.5.29';
+import { getPackageVersion } from '../version.js';
+const VERSION = getPackageVersion();
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
@@ -170,7 +171,13 @@ function cleanupPreviousAgent(projectId, apiPort, devPort) {
         killPort(apiPort);
     if (devPort !== oldDevPort)
         killPort(devPort);
-    // 4. Clear stale project config
+    // 4. Also free the backend port (devPort + 1001) that DevServer uses for Express
+    const backendPort = devPort + 1001;
+    killPort(backendPort);
+    const oldBackendPort = oldDevPort ? oldDevPort + 1001 : 0;
+    if (oldBackendPort && oldBackendPort !== backendPort)
+        killPort(oldBackendPort);
+    // 5. Clear stale project config
     clearProjectConfig(projectId);
 }
 export async function startCommand(directory, options) {

package/dist/commands/update.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Update command — update both CLI (npm) and desktop app (GitHub releases).
+ *
+ * Usage:
+ *   nstantpage update          — Update both CLI and desktop
+ *   nstantpage update --cli    — Update CLI only (npm)
+ *   nstantpage update --desktop — Update desktop only (GitHub releases)
+ */
+interface UpdateOptions {
+    cli?: boolean;
+    desktop?: boolean;
+}
+export declare function updateCommand(options?: UpdateOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,73 @@
+/**
+ * Update command — update both CLI (npm) and desktop app (GitHub releases).
+ *
+ * Usage:
+ *   nstantpage update          — Update both CLI and desktop
+ *   nstantpage update --cli    — Update CLI only (npm)
+ *   nstantpage update --desktop — Update desktop only (GitHub releases)
+ */
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { getPackageVersion } from '../version.js';
+const DESKTOP_DIR = path.join(os.homedir(), '.nstantpage', 'desktop');
+const VERSION_FILE = path.join(DESKTOP_DIR, '.version');
+export async function updateCommand(options = {}) {
+    const updateBoth = !options.cli && !options.desktop;
+    const currentVersion = getPackageVersion();
+    console.log(chalk.blue(`\n  nstantpage v${currentVersion}\n`));
+    if (updateBoth || options.cli) {
+        await updateCli(currentVersion);
+    }
+    if (updateBoth || options.desktop) {
+        await updateDesktop();
+    }
+    console.log('');
+}
+async function updateCli(currentVersion) {
+    console.log(chalk.gray('  Checking npm for CLI updates...'));
+    try {
+        const latest = execSync('npm view nstantpage-agent version 2>/dev/null', {
+            encoding: 'utf-8',
+        }).trim();
+        if (latest === currentVersion) {
+            console.log(chalk.green(`  ✓ CLI is up to date (${currentVersion})`));
+            return;
+        }
+        console.log(chalk.yellow(`  Updating CLI: ${currentVersion} → ${latest}`));
+        execSync('npm install -g nstantpage-agent@latest', {
+            stdio: 'inherit',
+        });
+        console.log(chalk.green(`  ✓ CLI updated to ${latest}`));
+    }
+    catch (err) {
+        console.log(chalk.red(`  ✗ CLI update failed: ${err.message}`));
+        console.log(chalk.gray('  Try manually: npm install -g nstantpage-agent@latest'));
+    }
+}
+async function updateDesktop() {
+    console.log(chalk.gray('  Checking GitHub for desktop updates...'));
+    try {
+        // Re-run the postinstall script which handles download + version check
+        const scriptPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', 'scripts', 'postinstall.mjs');
+        if (fs.existsSync(scriptPath)) {
+            execSync(`node "${scriptPath}"`, { stdio: 'inherit' });
+        }
+        else {
+            // If installed globally, the script is in the package root
+            const altPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'scripts', 'postinstall.mjs');
+            if (fs.existsSync(altPath)) {
+                execSync(`node "${altPath}"`, { stdio: 'inherit' });
+            }
+            else {
+                console.log(chalk.yellow('  ⚠ Desktop updater script not found. Reinstall to fix: npm i -g nstantpage-agent'));
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`  ✗ Desktop update failed: ${err.message}`));
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/fileManager.d.ts

@@ -36,6 +36,17 @@ export declare class FileManager {
      * Get the project directory path.
      */
     getProjectDir(): string;
+    /**
+     * Build a recursive file tree of the project directory.
+     * Returns a structure matching the backend's /api/projects/{id}/tree format.
+     */
+    getFileTree(): Promise<{
+        name: string;
+        path: string;
+        isDirectory: boolean;
+        children: any[];
+    }>;
+    private buildTree;
     /**
      * Check if a path exists.
      */

package/dist/fileManager.js

@@ -101,6 +101,50 @@ export class FileManager {
     getProjectDir() {
         return this.projectDir;
     }
+    /**
+     * Build a recursive file tree of the project directory.
+     * Returns a structure matching the backend's /api/projects/{id}/tree format.
+     */
+    async getFileTree() {
+        const root = {
+            name: path.basename(this.projectDir),
+            path: '',
+            isDirectory: true,
+            children: [],
+        };
+        if (existsSync(this.projectDir)) {
+            root.children = await this.buildTree(this.projectDir, '');
+        }
+        return root;
+    }
+    async buildTree(dir, relativePath) {
+        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 = [];
+        // Sort: directories first, then alphabetically
+        const sorted = entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of sorted) {
+            if (entry.name.startsWith('.') && entry.name !== '.env')
+                continue;
+            const entryRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                const children = await this.buildTree(path.join(dir, entry.name), entryRelPath);
+                result.push({ name: entry.name, path: entryRelPath, isDirectory: true, children });
+            }
+            else {
+                result.push({ name: entry.name, path: entryRelPath, isDirectory: false, children: [] });
+            }
+        }
+        return result;
+    }
     /**
      * Check if a path exists.
      */

package/dist/localServer.d.ts

@@ -129,6 +129,9 @@ export declare class LocalServer {
     private handlePushToBackend;
     private handlePullFromBackend;
     private handleDiskFile;
+    private handleTree;
+    private handleFileContent;
+    private handleSaveFile;
     private handleHealth;
     /**
      * Get a pg Pool connected to this project's local database.

package/dist/localServer.js

@@ -25,6 +25,7 @@ import { ErrorStore, structuredErrorToString } from './errorStore.js';
 import { PackageInstaller } from './packageInstaller.js';
 import { probeLocalPostgres, ensureLocalProjectDb, isLocalPgAvailable, writeDatabaseUrlToEnv } from './projectDb.js';
 import { AgentSync } from './agentSync.js';
+import { getPackageVersion } from './version.js';
 // ─── Try to load node-pty for real PTY support ─────────────────
 let ptyModule = null;
 try {
@@ -405,6 +406,9 @@ export class LocalServer {
             '/live/push-to-backend': this.handlePushToBackend,
             '/live/pull-from-backend': this.handlePullFromBackend,
             '/live/disk-file': this.handleDiskFile,
+            '/live/tree': this.handleTree,
+            '/live/file-content': this.handleFileContent,
+            '/live/save-file': this.handleSaveFile,
             '/health': this.handleHealth,
         };
         if (handlers[path])
@@ -828,7 +832,7 @@ export class LocalServer {
             connected: true,
             projectId: this.options.projectId,
             agent: {
-                version: '0.5.11',
+                version: getPackageVersion(),
                 hostname: os.hostname(),
                 platform: `${os.platform()} ${os.arch()}`,
             },
@@ -1272,6 +1276,50 @@ export class LocalServer {
             this.json(res, { success: false, error: error.message }, 500);
         }
     }
+    // ─── /live/tree ──────────────────────────────────────────────
+    async handleTree(_req, res) {
+        try {
+            const tree = await this.fileManager.getFileTree();
+            this.json(res, tree);
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    // ─── /live/file-content ──────────────────────────────────────
+    async handleFileContent(_req, res, _body, url) {
+        const filePath = url.searchParams.get('path');
+        if (!filePath) {
+            this.json(res, { error: 'Missing path parameter' }, 400);
+            return;
+        }
+        try {
+            const content = await this.fileManager.readFile(filePath);
+            if (content === null) {
+                this.json(res, { error: 'File not found' }, 404);
+                return;
+            }
+            this.json(res, { content });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
+    // ─── /live/save-file ────────────────────────────────────────
+    async handleSaveFile(_req, res, body) {
+        try {
+            const { filePath, content } = JSON.parse(body);
+            if (!filePath || content === undefined) {
+                this.json(res, { error: 'filePath and content required' }, 400);
+                return;
+            }
+            await this.fileManager.writeFiles({ [filePath]: content });
+            this.json(res, { success: true, message: 'File saved' });
+        }
+        catch (error) {
+            this.json(res, { error: error.message }, 500);
+        }
+    }
     // ─── /health ─────────────────────────────────────────────────
     async handleHealth(_req, res) {
         this.json(res, {

package/dist/packageInstaller.js

@@ -62,7 +62,20 @@ export class PackageInstaller {
             console.log(`  [Installer] Installing project dependencies...`);
             const pm = this.detectPackageManager();
             const args = this.buildFastInstallArgs(pm);
-            await this.runCommand(pm, args, 300_000);
+            try {
+                await this.runCommand(pm, args, 300_000);
+            }
+            catch (err) {
+                // Frozen-lockfile failed (lockfile out-of-date) — retry without it
+                if (String(err.message || err).includes('ERR_PNPM_OUTDATED_LOCKFILE') ||
+                    String(err.message || err).includes('frozen-lockfile')) {
+                    console.log(`  [Installer] Lockfile outdated — retrying without frozen-lockfile...`);
+                    await this.runCommand(pm, ['install', '--no-frozen-lockfile'], 300_000);
+                }
+                else {
+                    throw err;
+                }
+            }
             this.writeDepsHash();
             console.log(`  [Installer] Dependencies installed`);
         }