nstantpage-agent 0.5.34 → 0.6.1

package/dist/cli.bundle.js

@@ -972,8 +972,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path17 = __require("node:path");
-    var fs18 = __require("node:fs");
+    var path20 = __require("node:path");
+    var fs21 = __require("node:fs");
     var process15 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1905,11 +1905,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path17.resolve(baseDir, baseName);
-          if (fs18.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path17.extname(baseName))) return void 0;
+          const localBin = path20.resolve(baseDir, baseName);
+          if (fs21.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path20.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs18.existsSync(`${localBin}${ext}`)
+            (ext) => fs21.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1921,21 +1921,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs21.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path17.resolve(
-            path17.dirname(resolvedScriptPath),
+          executableDir = path20.resolve(
+            path20.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path17.basename(
+            const legacyName = path20.basename(
               this._scriptPath,
-              path17.extname(this._scriptPath)
+              path20.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1946,7 +1946,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path17.extname(executableFile));
+        launchWithNode = sourceExt.includes(path20.extname(executableFile));
         let proc;
         if (process15.platform !== "win32") {
           if (launchWithNode) {
@@ -2786,7 +2786,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path17.basename(filename, path17.extname(filename));
+        this._name = path20.basename(filename, path20.extname(filename));
         return this;
       }
       /**
@@ -2800,9 +2800,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path18) {
-        if (path18 === void 0) return this._executableDir;
-        this._executableDir = path18;
+      executableDir(path21) {
+        if (path21 === void 0) return this._executableDir;
+        this._executableDir = path21;
         return this;
       }
       /**
@@ -3033,12 +3033,12 @@ var require_commander = __commonJS({
 });
 
 // node_modules/dot-prop/index.js
-function getPathSegments(path17) {
+function getPathSegments(path20) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path17) {
+  for (const character of path20) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -3160,11 +3160,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path17, value) {
-  if (!isObject(object) || typeof path17 !== "string") {
+function getProperty(object, path20, value) {
+  if (!isObject(object) || typeof path20 !== "string") {
     return value === void 0 ? object : value;
   }
-  const pathArray = getPathSegments(path17);
+  const pathArray = getPathSegments(path20);
   if (pathArray.length === 0) {
     return value;
   }
@@ -3184,12 +3184,12 @@ function getProperty(object, path17, value) {
   }
   return object === void 0 ? value : object;
 }
-function setProperty(object, path17, value) {
-  if (!isObject(object) || typeof path17 !== "string") {
+function setProperty(object, path20, value) {
+  if (!isObject(object) || typeof path20 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path17);
+  const pathArray = getPathSegments(path20);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -3202,11 +3202,11 @@ function setProperty(object, path17, value) {
   }
   return root;
 }
-function deleteProperty(object, path17) {
-  if (!isObject(object) || typeof path17 !== "string") {
+function deleteProperty(object, path20) {
+  if (!isObject(object) || typeof path20 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path17);
+  const pathArray = getPathSegments(path20);
   for (let index = 0; index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -3220,11 +3220,11 @@ function deleteProperty(object, path17) {
     }
   }
 }
-function hasProperty(object, path17) {
-  if (!isObject(object) || typeof path17 !== "string") {
+function hasProperty(object, path20) {
+  if (!isObject(object) || typeof path20 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path17);
+  const pathArray = getPathSegments(path20);
   if (pathArray.length === 0) {
     return false;
   }
@@ -7006,8 +7006,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path17) {
-      let input = path17;
+    function removeDotSegments(path20) {
+      let input = path20;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -7206,8 +7206,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path17, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
+        const [path20, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path20 && path20 !== "/" ? path20 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -11393,12 +11393,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs18, exportName) {
+    function addFormats(ajv, list, fs21, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs18[f]);
+        ajv.addFormat(f, fs21[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -19294,15 +19294,15 @@ var require_pg_connection_string = __commonJS({
       if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
         config.ssl = {};
       }
-      const fs18 = config.sslcert || config.sslkey || config.sslrootcert ? __require("fs") : null;
+      const fs21 = config.sslcert || config.sslkey || config.sslrootcert ? __require("fs") : null;
       if (config.sslcert) {
-        config.ssl.cert = fs18.readFileSync(config.sslcert).toString();
+        config.ssl.cert = fs21.readFileSync(config.sslcert).toString();
       }
       if (config.sslkey) {
-        config.ssl.key = fs18.readFileSync(config.sslkey).toString();
+        config.ssl.key = fs21.readFileSync(config.sslkey).toString();
       }
       if (config.sslrootcert) {
-        config.ssl.ca = fs18.readFileSync(config.sslrootcert).toString();
+        config.ssl.ca = fs21.readFileSync(config.sslrootcert).toString();
       }
       if (options.useLibpqCompat && config.uselibpqcompat) {
         throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -21067,7 +21067,7 @@ var require_split2 = __commonJS({
 var require_helper = __commonJS({
   "node_modules/pgpass/lib/helper.js"(exports, module) {
     "use strict";
-    var path17 = __require("path");
+    var path20 = __require("path");
     var Stream = __require("stream").Stream;
     var split = require_split2();
     var util = __require("util");
@@ -21106,7 +21106,7 @@ var require_helper = __commonJS({
     };
     module.exports.getFileName = function(rawEnv) {
       var env3 = rawEnv || process.env;
-      var file = env3.PGPASSFILE || (isWin ? path17.join(env3.APPDATA || "./", "postgresql", "pgpass.conf") : path17.join(env3.HOME || "./", ".pgpass"));
+      var file = env3.PGPASSFILE || (isWin ? path20.join(env3.APPDATA || "./", "postgresql", "pgpass.conf") : path20.join(env3.HOME || "./", ".pgpass"));
       return file;
     };
     module.exports.usePgPass = function(stats, fname) {
@@ -21238,16 +21238,16 @@ var require_helper = __commonJS({
 var require_lib = __commonJS({
   "node_modules/pgpass/lib/index.js"(exports, module) {
     "use strict";
-    var path17 = __require("path");
-    var fs18 = __require("fs");
+    var path20 = __require("path");
+    var fs21 = __require("fs");
     var helper = require_helper();
     module.exports = function(connInfo, cb) {
       var file = helper.getFileName();
-      fs18.stat(file, function(err, stat) {
+      fs21.stat(file, function(err, stat) {
         if (err || !helper.usePgPass(stat, file)) {
           return cb(void 0);
         }
-        var st = fs18.createReadStream(file);
+        var st = fs21.createReadStream(file);
         helper.getPassword(connInfo, st, cb);
       });
     };
@@ -23989,8 +23989,8 @@ async function logoutCommand() {
 
 // dist/commands/start.js
 init_config();
-import path15 from "path";
-import fs16 from "fs";
+import path16 from "path";
+import fs17 from "fs";
 import os10 from "os";
 import { execSync as execSync2 } from "child_process";
 
@@ -24009,8 +24009,8 @@ init_config();
 
 // dist/localServer.js
 import http3 from "http";
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 import os7 from "os";
 import { createRequire } from "module";
 import { spawn as spawn4 } from "child_process";
@@ -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.
    */
@@ -24774,7 +24816,16 @@ var PackageInstaller = class {
       console.log(`  [Installer] Installing project dependencies...`);
       const pm = this.detectPackageManager();
       const args = this.buildFastInstallArgs(pm);
-      await this.runCommand(pm, args, 3e5);
+      try {
+        await this.runCommand(pm, args, 3e5);
+      } catch (err) {
+        if (String(err.message || err).includes("ERR_PNPM_OUTDATED_LOCKFILE") || String(err.message || err).includes("frozen-lockfile")) {
+          console.log(`  [Installer] Lockfile outdated \u2014 retrying without frozen-lockfile...`);
+          await this.runCommand(pm, ["install", "--no-frozen-lockfile"], 3e5);
+        } else {
+          throw err;
+        }
+      }
       this.writeDepsHash();
       console.log(`  [Installer] Dependencies installed`);
     } finally {
@@ -25694,11 +25745,40 @@ var AgentSync = class {
   }
 };
 
+// dist/version.js
+import fs14 from "fs";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename_esm = fileURLToPath2(import.meta.url);
+var __dirname_esm = path13.dirname(__filename_esm);
+var _version = null;
+function getPackageVersion() {
+  if (_version)
+    return _version;
+  let dir = __dirname_esm;
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path13.join(dir, "package.json");
+    if (fs14.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "nstantpage-agent") {
+          _version = pkg.version;
+          return _version;
+        }
+      } catch {
+      }
+    }
+    dir = path13.dirname(dir);
+  }
+  _version = "0.0.0";
+  return _version;
+}
+
 // dist/localServer.js
 var ptyModule = null;
 try {
-  const _require = createRequire(import.meta.url);
-  ptyModule = _require("node-pty");
+  const _require2 = createRequire(import.meta.url);
+  ptyModule = _require2("node-pty");
 } catch {
 }
 var terminalSessions = /* @__PURE__ */ new Map();
@@ -25986,7 +26066,7 @@ Access-Control-Allow-Origin: *\r
       res.end(JSON.stringify({ error: `Unknown endpoint: ${pathOnly}` }));
     }
   }
-  getHandler(path17) {
+  getHandler(path20) {
     const handlers = {
       "/live/sync": this.handleSync,
       "/live/files": this.handleFiles,
@@ -26033,12 +26113,15 @@ 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])
-      return handlers[path17];
+    if (handlers[path20])
+      return handlers[path20];
     for (const [route, handler] of Object.entries(handlers)) {
-      if (path17.startsWith(route + "/"))
+      if (path20.startsWith(route + "/"))
         return handler;
     }
     return null;
@@ -26260,7 +26343,7 @@ Access-Control-Allow-Origin: *\r
     const label = parsed.label || `Terminal ${sessionCounter}`;
     let shell = null;
     let ptyProcess = null;
-    const spawnCwd = fs14.existsSync(this.options.projectDir) ? this.options.projectDir : process.cwd();
+    const spawnCwd = fs15.existsSync(this.options.projectDir) ? this.options.projectDir : process.cwd();
     if (ptyModule) {
       try {
         ptyProcess = ptyModule.spawn(shellCmd, [], {
@@ -26422,7 +26505,7 @@ Access-Control-Allow-Origin: *\r
       connected: true,
       projectId: this.options.projectId,
       agent: {
-        version: "0.5.11",
+        version: getPackageVersion(),
         hostname: os7.hostname(),
         platform: `${os7.platform()} ${os7.arch()}`
       }
@@ -26684,7 +26767,7 @@ Access-Control-Allow-Origin: *\r
     const projectDir = this.options.projectDir;
     console.log(`  [LocalServer] Running production build for project ${this.options.projectId}...`);
     try {
-      const hasBuildScript = fs14.existsSync(path13.join(projectDir, "script", "build.ts"));
+      const hasBuildScript = fs15.existsSync(path14.join(projectDir, "script", "build.ts"));
       const buildCmd = hasBuildScript ? "npx tsx script/build.ts" : "npx vite build";
       const buildResult = await new Promise((resolve) => {
         const proc = spawn4("sh", ["-c", buildCmd], {
@@ -26708,32 +26791,32 @@ Access-Control-Allow-Origin: *\r
         this.json(res, { success: false, error: errorMsg });
         return;
       }
-      const distDir = path13.join(projectDir, "dist");
-      if (!fs14.existsSync(distDir)) {
+      const distDir = path14.join(projectDir, "dist");
+      if (!fs15.existsSync(distDir)) {
         this.json(res, { success: false, error: "dist/ not found after build" });
         return;
       }
       const files = {};
       const collectFiles = (dir, prefix) => {
-        const entries = fs14.readdirSync(dir, { withFileTypes: true });
+        const entries = fs15.readdirSync(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path13.join(dir, entry.name);
+          const fullPath = path14.join(dir, entry.name);
           const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             collectFiles(fullPath, relPath);
           } else {
-            const ext = path13.extname(entry.name).toLowerCase();
+            const ext = path14.extname(entry.name).toLowerCase();
             const isBinary = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".woff", ".woff2", ".ttf", ".eot", ".mp3", ".mp4", ".ogg", ".wav"].includes(ext);
             if (isBinary) {
-              files[relPath] = "base64:" + fs14.readFileSync(fullPath).toString("base64");
+              files[relPath] = "base64:" + fs15.readFileSync(fullPath).toString("base64");
             } else {
-              files[relPath] = fs14.readFileSync(fullPath, "utf-8");
+              files[relPath] = fs15.readFileSync(fullPath, "utf-8");
             }
           }
         }
       };
       collectFiles(distDir, "");
-      const hasBackend = fs14.existsSync(path13.join(projectDir, "server", "index.ts")) || fs14.existsSync(path13.join(projectDir, "server", "index.js"));
+      const hasBackend = fs15.existsSync(path14.join(projectDir, "server", "index.ts")) || fs15.existsSync(path14.join(projectDir, "server", "index.js"));
       console.log(`  [LocalServer] Build completed: ${Object.keys(files).length} files (backend=${hasBackend})`);
       this.json(res, {
         success: true,
@@ -26834,6 +26917,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, {
@@ -27118,7 +27242,7 @@ var TunnelClient = class {
         this.emitStatus("connected");
         this.send({
           type: "agent-info",
-          version: "0.5.11",
+          version: getPackageVersion(),
           hostname: os8.hostname(),
           platform: `${os8.platform()} ${os8.arch()}`,
           deviceId: getDeviceId(),
@@ -27563,11 +27687,21 @@ var TunnelClient = class {
 
 // dist/statusServer.js
 import http5 from "http";
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path15 from "path";
 import os9 from "os";
+import { spawn as spawn5 } from "child_process";
+import { createRequire as createRequire2 } from "module";
 var STATUS_PORT = 18999;
-var STATUS_FILE = path14.join(os9.homedir(), ".nstantpage", "status.json");
+var STATUS_FILE = path15.join(os9.homedir(), ".nstantpage", "status.json");
+var _require = createRequire2(import.meta.url);
+var ptyModule2 = null;
+try {
+  ptyModule2 = _require("node-pty");
+} catch {
+}
+var repoTerminalSessions = /* @__PURE__ */ new Map();
+var repoSessionCounter = 0;
 var StatusServer = class {
   server = null;
   getStatus;
@@ -27582,7 +27716,8 @@ var StatusServer = class {
     return new Promise((resolve, reject) => {
       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-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-project-id");
         res.setHeader("Content-Type", "application/json");
         if (req.method === "OPTIONS") {
           res.writeHead(204);
@@ -27642,9 +27777,549 @@ 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 || !fs16.existsSync(dir)) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Missing or invalid dir parameter" }));
+            return;
+          }
+          try {
+            const tree = buildFileTree(dir, path15.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 = path15.resolve(dir, filePath);
+          if (!fullPath.startsWith(path15.resolve(dir))) {
+            res.writeHead(403);
+            res.end(JSON.stringify({ error: "Path traversal not allowed" }));
+            return;
+          }
+          try {
+            if (!fs16.existsSync(fullPath)) {
+              res.writeHead(404);
+              res.end(JSON.stringify({ error: "File not found" }));
+              return;
+            }
+            const content = fs16.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 = path15.resolve(dir, filePath);
+              if (!fullPath.startsWith(path15.resolve(dir))) {
+                res.writeHead(403);
+                res.end(JSON.stringify({ error: "Path traversal not allowed" }));
+                return;
+              }
+              const parentDir = path15.dirname(fullPath);
+              if (!fs16.existsSync(parentDir))
+                fs16.mkdirSync(parentDir, { recursive: true });
+              fs16.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;
+        }
+        if (req.method === "GET" && url === "/browse/list-files") {
+          const dir = parsedUrl.searchParams.get("dir");
+          if (!dir || !fs16.existsSync(dir)) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: "Missing or invalid dir parameter" }));
+            return;
+          }
+          try {
+            const files = [];
+            collectFilesRecursive(dir, dir, files);
+            res.writeHead(200);
+            res.end(JSON.stringify({ files }));
+          } catch (err) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: err.message }));
+          }
+          return;
+        }
+        if (req.method === "POST" && url === "/browse/search") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const { dir, query, isRegex, filePattern } = JSON.parse(body);
+              if (!dir || !query) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "dir and query required" }));
+                return;
+              }
+              if (!fs16.existsSync(dir)) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "dir does not exist" }));
+                return;
+              }
+              const files = [];
+              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 && !matchGlob(f.filePath, filePattern))
+                  continue;
+                const fullPath = path15.resolve(dir, f.filePath);
+                let content;
+                try {
+                  content = fs16.readFileSync(fullPath, "utf-8");
+                } catch {
+                  continue;
+                }
+                const lines = content.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] });
+                  }
+                }
+              }
+              res.writeHead(200);
+              res.end(JSON.stringify({ results }));
+            } catch (err) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          });
+          return;
+        }
+        if (req.method === "POST" && url === "/browse/delete") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const { dir, filePath } = JSON.parse(body);
+              if (!dir || !filePath) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "dir and filePath required" }));
+                return;
+              }
+              const fullPath = path15.resolve(dir, filePath);
+              if (!fullPath.startsWith(path15.resolve(dir))) {
+                res.writeHead(403);
+                res.end(JSON.stringify({ error: "Path traversal not allowed" }));
+                return;
+              }
+              if (!fs16.existsSync(fullPath)) {
+                res.writeHead(404);
+                res.end(JSON.stringify({ error: "File not found" }));
+                return;
+              }
+              fs16.unlinkSync(fullPath);
+              res.writeHead(200);
+              res.end(JSON.stringify({ success: true }));
+            } catch (err) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          });
+          return;
+        }
+        if (url === "/live/container-status") {
+          res.writeHead(200);
+          res.end(JSON.stringify({ status: "idle", projectId: parsedUrl.searchParams.get("projectId") || "repo" }));
+          return;
+        }
+        if (req.method === "POST" && url === "/live/terminal") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const parsed = body ? JSON.parse(body) : {};
+              const command = parsed.command || "";
+              const cwd = parsed.cwd || os9.homedir();
+              const timeoutSeconds = Math.min(parsed.timeoutSeconds || 120, 600);
+              const projectId = parsed.projectId || "repo";
+              if (!command) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ success: false, error: "command is required" }));
+                return;
+              }
+              const spawnCwd = fs16.existsSync(cwd) ? cwd : os9.homedir();
+              const shellCmd = process.platform === "win32" ? "cmd.exe" : process.env.SHELL || "/bin/bash";
+              const shellEnv = { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor", FORCE_COLOR: "3" };
+              const aiSession = Array.from(repoTerminalSessions.values()).find((s) => s.projectId === projectId && s.isAiSession && !s.exited);
+              let stdout = "";
+              let stderr = "";
+              let finished = false;
+              const child = spawn5(shellCmd, ["-c", command], {
+                cwd: spawnCwd,
+                env: shellEnv,
+                stdio: ["pipe", "pipe", "pipe"]
+              });
+              child.stdout?.on("data", (d) => {
+                const str = d.toString();
+                stdout += str;
+                if (aiSession) {
+                  for (const listener of aiSession.dataListeners) {
+                    try {
+                      listener(`\x1B[90m$ ${command}\x1B[0m
+`);
+                    } catch {
+                    }
+                  }
+                  for (const listener of aiSession.dataListeners) {
+                    try {
+                      listener(str);
+                    } catch {
+                    }
+                  }
+                }
+              });
+              child.stderr?.on("data", (d) => {
+                const str = d.toString();
+                stderr += str;
+                if (aiSession) {
+                  for (const listener of aiSession.dataListeners) {
+                    try {
+                      listener(str);
+                    } catch {
+                    }
+                  }
+                }
+              });
+              const timeout = setTimeout(() => {
+                if (!finished) {
+                  finished = true;
+                  try {
+                    child.kill("SIGKILL");
+                  } catch {
+                  }
+                  res.writeHead(200);
+                  res.end(JSON.stringify({
+                    success: false,
+                    exitCode: 124,
+                    stdout: stdout.slice(-5e4),
+                    stderr: stderr.slice(-5e4),
+                    error: `Timeout after ${timeoutSeconds}s`
+                  }));
+                }
+              }, timeoutSeconds * 1e3);
+              child.on("exit", (code) => {
+                if (finished)
+                  return;
+                finished = true;
+                clearTimeout(timeout);
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                  success: code === 0,
+                  exitCode: code ?? -1,
+                  stdout: stdout.slice(-5e4),
+                  stderr: stderr.slice(-5e4),
+                  error: null
+                }));
+              });
+              child.on("error", (err) => {
+                if (finished)
+                  return;
+                finished = true;
+                clearTimeout(timeout);
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                  success: false,
+                  exitCode: -1,
+                  stdout: "",
+                  stderr: "",
+                  error: err.message
+                }));
+              });
+            } catch (err) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          });
+          return;
+        }
+        if (url === "/live/terminal/sessions") {
+          if (req.method === "GET") {
+            const pid = parsedUrl.searchParams.get("projectId") || "repo";
+            const sessions = Array.from(repoTerminalSessions.values()).filter((s) => s.projectId === pid).map((s) => ({
+              id: s.id,
+              projectId: s.projectId,
+              isAiSession: s.isAiSession,
+              label: s.label,
+              createdAt: s.createdAt,
+              lastActivity: s.lastActivity,
+              exited: s.exited,
+              exitCode: s.exitCode,
+              cols: s.cols,
+              rows: s.rows
+            }));
+            res.writeHead(200);
+            res.end(JSON.stringify({ success: true, sessions }));
+            return;
+          }
+          if (req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => {
+              body += chunk.toString();
+            });
+            req.on("end", () => {
+              try {
+                const parsed = body ? JSON.parse(body) : {};
+                const projectId = parsed.projectId || "repo";
+                const cwd = parsed.cwd || os9.homedir();
+                const cols = parsed.cols || 120;
+                const rows = parsed.rows || 30;
+                repoSessionCounter++;
+                const sessionId = `repo-${Date.now()}-${repoSessionCounter}`;
+                const label = parsed.label || `Terminal ${repoSessionCounter}`;
+                const shellCmd = process.platform === "win32" ? "cmd.exe" : process.env.SHELL || "/bin/bash";
+                const shellEnv = { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor", FORCE_COLOR: "3", COLUMNS: String(cols), LINES: String(rows) };
+                const spawnCwd = fs16.existsSync(cwd) ? cwd : os9.homedir();
+                let shell = null;
+                let ptyProcess = null;
+                if (ptyModule2) {
+                  try {
+                    ptyProcess = ptyModule2.spawn(shellCmd, [], { name: "xterm-256color", cols, rows, cwd: spawnCwd, env: shellEnv });
+                  } catch {
+                    ptyProcess = null;
+                  }
+                }
+                if (!ptyProcess) {
+                  try {
+                    shell = spawn5(shellCmd, ["-i"], { cwd: spawnCwd, env: shellEnv, stdio: ["pipe", "pipe", "pipe"] });
+                  } catch {
+                    shell = spawn5(shellCmd, [], { cwd: spawnCwd, env: shellEnv, stdio: ["pipe", "pipe", "pipe"] });
+                  }
+                }
+                const session = {
+                  id: sessionId,
+                  projectId,
+                  cwd: spawnCwd,
+                  shell,
+                  ptyProcess,
+                  outputBuffer: [],
+                  createdAt: Date.now(),
+                  lastActivity: Date.now(),
+                  cols,
+                  rows,
+                  isAiSession: parsed.isAiSession || false,
+                  label,
+                  exited: false,
+                  exitCode: null,
+                  dataListeners: /* @__PURE__ */ new Set(),
+                  exitListeners: /* @__PURE__ */ new Set()
+                };
+                const pushOutput = (str) => {
+                  session.outputBuffer.push(str);
+                  session.lastActivity = Date.now();
+                  while (session.outputBuffer.length > 500)
+                    session.outputBuffer.shift();
+                  for (const listener of session.dataListeners) {
+                    try {
+                      listener(str);
+                    } catch {
+                    }
+                  }
+                };
+                const handleExit = (code) => {
+                  session.exited = true;
+                  session.exitCode = code;
+                  for (const listener of session.exitListeners) {
+                    try {
+                      listener(code);
+                    } catch {
+                    }
+                  }
+                };
+                if (ptyProcess) {
+                  ptyProcess.onData((data) => pushOutput(data));
+                  ptyProcess.onExit(({ exitCode }) => handleExit(exitCode));
+                } else if (shell) {
+                  shell.stdout?.on("data", (d) => pushOutput(d.toString()));
+                  shell.stderr?.on("data", (d) => pushOutput(d.toString()));
+                  shell.on("exit", (code) => handleExit(code));
+                }
+                repoTerminalSessions.set(sessionId, session);
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                  success: true,
+                  session: { id: sessionId, projectId, isAiSession: session.isAiSession, label, createdAt: session.createdAt, lastActivity: session.lastActivity, exited: false, exitCode: null, cols, rows }
+                }));
+              } catch (err) {
+                res.writeHead(500);
+                res.end(JSON.stringify({ error: err.message }));
+              }
+            });
+            return;
+          }
+        }
+        if (req.method === "DELETE" && url?.startsWith("/live/terminal/sessions/")) {
+          const sessionId = url.split("/").pop();
+          const session = repoTerminalSessions.get(sessionId);
+          if (session) {
+            if (session.ptyProcess) {
+              try {
+                session.ptyProcess.kill();
+              } catch {
+              }
+            }
+            if (session.shell) {
+              try {
+                session.shell.kill();
+              } catch {
+              }
+            }
+            repoTerminalSessions.delete(sessionId);
+          }
+          res.writeHead(200);
+          res.end(JSON.stringify({ success: true }));
+          return;
+        }
+        if (req.method === "POST" && url === "/live/terminal/destroy") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const { sessionId } = JSON.parse(body);
+              const session = repoTerminalSessions.get(sessionId);
+              if (session) {
+                if (session.ptyProcess) {
+                  try {
+                    session.ptyProcess.kill();
+                  } catch {
+                  }
+                }
+                if (session.shell) {
+                  try {
+                    session.shell.kill();
+                  } catch {
+                  }
+                }
+                repoTerminalSessions.delete(sessionId);
+              }
+              res.writeHead(200);
+              res.end(JSON.stringify({ success: true }));
+            } catch (err) {
+              res.writeHead(500);
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          });
+          return;
+        }
+        if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === "websocket") {
+          return;
+        }
         res.writeHead(404);
         res.end(JSON.stringify({ error: "Not found" }));
       });
+      const wss = new import_websocket_server.default({ noServer: true });
+      this.server.on("upgrade", (req, socket, head) => {
+        const urlMatch = req.url?.match(/^\/live\/terminal\/ws\/([^/]+)\/([^/?]+)/);
+        if (!urlMatch) {
+          socket.destroy();
+          return;
+        }
+        const sessionId = urlMatch[2];
+        const session = repoTerminalSessions.get(sessionId);
+        if (!session) {
+          socket.destroy();
+          return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          if (session.outputBuffer.length > 0) {
+            ws.send(JSON.stringify({ type: "scrollback", data: session.outputBuffer.join("") }));
+          }
+          ws.send(JSON.stringify({ type: "connected", sessionId: session.id, projectId: session.projectId }));
+          const dataListener = (data) => {
+            try {
+              if (ws.readyState === import_websocket.default.OPEN)
+                ws.send(JSON.stringify({ type: "output", data }));
+            } catch {
+            }
+          };
+          const exitListener = (code) => {
+            try {
+              if (ws.readyState === import_websocket.default.OPEN)
+                ws.send(JSON.stringify({ type: "exit", exitCode: code }));
+            } catch {
+            }
+          };
+          session.dataListeners.add(dataListener);
+          session.exitListeners.add(exitListener);
+          ws.on("message", (raw) => {
+            try {
+              const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString());
+              if (msg.type === "input" && msg.data) {
+                if (session.ptyProcess)
+                  session.ptyProcess.write(msg.data);
+                else if (session.shell?.stdin)
+                  session.shell.stdin.write(msg.data);
+              } else if (msg.type === "resize" && msg.cols && msg.rows) {
+                session.cols = msg.cols;
+                session.rows = msg.rows;
+                if (session.ptyProcess) {
+                  try {
+                    session.ptyProcess.resize(msg.cols, msg.rows);
+                  } catch {
+                  }
+                }
+              }
+            } catch {
+            }
+          });
+          ws.on("close", () => {
+            session.dataListeners.delete(dataListener);
+            session.exitListeners.delete(exitListener);
+          });
+          ws.on("error", () => {
+            session.dataListeners.delete(dataListener);
+            session.exitListeners.delete(exitListener);
+          });
+        });
+      });
       this.server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
           console.log(`  [Status] Port ${STATUS_PORT} in use \u2014 status server skipped`);
@@ -27653,7 +28328,7 @@ var StatusServer = class {
         }
         reject(err);
       });
-      this.server.listen(STATUS_PORT, "127.0.0.1", () => {
+      this.server.listen(STATUS_PORT, () => {
         this.writeStatusFile();
         resolve();
       });
@@ -27665,25 +28340,134 @@ var StatusServer = class {
       this.server = null;
     }
     try {
-      if (fs15.existsSync(STATUS_FILE))
-        fs15.unlinkSync(STATUS_FILE);
+      if (fs16.existsSync(STATUS_FILE))
+        fs16.unlinkSync(STATUS_FILE);
     } catch {
     }
   }
   writeStatusFile() {
-    const dir = path14.dirname(STATUS_FILE);
-    if (!fs15.existsSync(dir))
-      fs15.mkdirSync(dir, { recursive: true });
-    fs15.writeFileSync(STATUS_FILE, JSON.stringify({
+    const dir = path15.dirname(STATUS_FILE);
+    if (!fs16.existsSync(dir))
+      fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(STATUS_FILE, JSON.stringify({
       port: STATUS_PORT,
       pid: process.pid,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     }, 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 = fs16.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(path15.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;
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ 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"
+]);
+function collectFilesRecursive(baseDir, currentDir, out) {
+  let entries;
+  try {
+    entries = fs16.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".env")
+      continue;
+    const fullPath = path15.join(currentDir, entry.name);
+    const relativePath = path15.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name))
+        continue;
+      collectFilesRecursive(baseDir, fullPath, out);
+    } else {
+      const ext = path15.extname(entry.name).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        out.push({ filePath: relativePath, totalLines: 0 });
+      } else {
+        try {
+          const content = fs16.readFileSync(fullPath, "utf-8");
+          out.push({ filePath: relativePath, totalLines: content.split("\n").length });
+        } catch {
+          out.push({ filePath: relativePath, totalLines: 0 });
+        }
+      }
+    }
+  }
+}
+function 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);
+}
 
 // dist/commands/start.js
-var VERSION = "0.5.29";
+var VERSION = getPackageVersion();
 function resolveBackendUrl(options) {
   if (options.backend)
     return options.backend.replace(/\/$/, "");
@@ -27692,10 +28476,10 @@ function resolveBackendUrl(options) {
 }
 function resolveProjectDir(directory, projectId, customDir) {
   if (customDir)
-    return path15.resolve(customDir);
+    return path16.resolve(customDir);
   if (directory !== ".")
-    return path15.resolve(directory);
-  const defaultBase = path15.join(os10.homedir(), ".nstantpage", "projects", projectId);
+    return path16.resolve(directory);
+  const defaultBase = path16.join(os10.homedir(), ".nstantpage", "projects", projectId);
   return defaultBase;
 }
 async function fetchProjectFiles(backendUrl, projectId, projectDir, token) {
@@ -27715,20 +28499,20 @@ async function fetchProjectFiles(backendUrl, projectId, projectDir, token) {
   if (!data.files || data.files.length === 0) {
     throw new Error("No files returned from backend. Is the project ID correct?");
   }
-  const versionFile = path15.join(projectDir, ".nstantpage-version");
-  const existingVersion = fs16.existsSync(versionFile) ? fs16.readFileSync(versionFile, "utf-8").trim() : null;
+  const versionFile = path16.join(projectDir, ".nstantpage-version");
+  const existingVersion = fs17.existsSync(versionFile) ? fs17.readFileSync(versionFile, "utf-8").trim() : null;
   if (existingVersion === String(data.versionId)) {
     console.log(source_default.gray(`  Files up-to-date (version ${data.version})`));
     return { fileCount: data.files.length, isNew: false, versionId: String(data.versionId) };
   }
   const dirsToCreate = /* @__PURE__ */ new Set();
   for (const file of data.files) {
-    const filePath = path15.join(projectDir, file.path);
-    dirsToCreate.add(path15.dirname(filePath));
+    const filePath = path16.join(projectDir, file.path);
+    dirsToCreate.add(path16.dirname(filePath));
   }
   for (const dir of dirsToCreate) {
-    if (!fs16.existsSync(dir)) {
-      fs16.mkdirSync(dir, { recursive: true });
+    if (!fs17.existsSync(dir)) {
+      fs17.mkdirSync(dir, { recursive: true });
     }
   }
   const BATCH_SIZE = 50;
@@ -27736,12 +28520,12 @@ async function fetchProjectFiles(backendUrl, projectId, projectDir, token) {
   for (let i = 0; i < data.files.length; i += BATCH_SIZE) {
     const batch = data.files.slice(i, i + BATCH_SIZE);
     await Promise.all(batch.map(async (file) => {
-      const filePath = path15.join(projectDir, file.path);
-      await fs16.promises.writeFile(filePath, file.content, "utf-8");
+      const filePath = path16.join(projectDir, file.path);
+      await fs17.promises.writeFile(filePath, file.content, "utf-8");
     }));
     written += batch.length;
   }
-  fs16.writeFileSync(versionFile, String(data.versionId), "utf-8");
+  fs17.writeFileSync(versionFile, String(data.versionId), "utf-8");
   console.log(source_default.green(`  \u2713 ${written} files downloaded (version ${data.version})`));
   return { fileCount: written, isNew: true, versionId: String(data.versionId) };
 }
@@ -27786,6 +28570,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) {
@@ -27840,8 +28629,8 @@ async function startCommand(directory, options) {
     apiPort = allocated.apiPort;
   }
   const projectDir = resolveProjectDir(directory, projectId, options.dir);
-  if (!fs16.existsSync(projectDir)) {
-    fs16.mkdirSync(projectDir, { recursive: true });
+  if (!fs17.existsSync(projectDir)) {
+    fs17.mkdirSync(projectDir, { recursive: true });
   }
   conf.set("projectId", projectId);
   cleanupPreviousAgent(projectId, apiPort, devPort);
@@ -27863,7 +28652,7 @@ async function startCommand(directory, options) {
     const { fileCount, isNew, versionId } = await fetchProjectFiles(backendUrl, projectId, projectDir, token);
     fetchedVersionId = versionId;
     if (!installer.areDependenciesInstalled()) {
-      if (fs16.existsSync(path15.join(projectDir, "package.json"))) {
+      if (fs17.existsSync(path16.join(projectDir, "package.json"))) {
         console.log(source_default.gray("  Installing dependencies..."));
         try {
           await installer.ensureDependencies();
@@ -27879,16 +28668,16 @@ async function startCommand(directory, options) {
   } catch (err) {
     console.log(source_default.yellow(`  \u26A0 Could not fetch project files: ${err.message}`));
     console.log(source_default.gray("    Continuing with existing local files (if any)..."));
-    if (!fs16.existsSync(path15.join(projectDir, "package.json"))) {
+    if (!fs17.existsSync(path16.join(projectDir, "package.json"))) {
       console.log(source_default.red(`
 \u2717 No package.json found and cannot fetch files from backend.`));
       console.log(source_default.gray("  Check your project ID and authentication."));
       process.exit(1);
     }
   }
-  const localConfigPath = path15.join(projectDir, ".nstantpage.json");
-  if (!fs16.existsSync(localConfigPath)) {
-    fs16.writeFileSync(localConfigPath, JSON.stringify({ projectId }, null, 2), "utf-8");
+  const localConfigPath = path16.join(projectDir, ".nstantpage.json");
+  if (!fs17.existsSync(localConfigPath)) {
+    fs17.writeFileSync(localConfigPath, JSON.stringify({ projectId }, null, 2), "utf-8");
   }
   let databaseUrl = null;
   try {
@@ -28112,9 +28901,9 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
         await existing.localServer.stop();
         activeProjects.delete(pid);
         const projectDir = resolveProjectDir(".", pid);
-        if (fs16.existsSync(projectDir)) {
+        if (fs17.existsSync(projectDir)) {
           console.log(source_default.gray(`  Wiping project directory: ${projectDir}`));
-          fs16.rmSync(projectDir, { recursive: true, force: true });
+          fs17.rmSync(projectDir, { recursive: true, force: true });
         }
       } else if (activeProjects.has(pid)) {
         console.log(source_default.yellow(`  Project ${pid} is already running`));
@@ -28277,8 +29066,8 @@ async function startAdditionalProject(projectId, opts) {
   try {
     const allocated = allocatePortsForProject(projectId);
     const projectDir = resolveProjectDir(".", projectId);
-    if (!fs16.existsSync(projectDir))
-      fs16.mkdirSync(projectDir, { recursive: true });
+    if (!fs17.existsSync(projectDir))
+      fs17.mkdirSync(projectDir, { recursive: true });
     cleanupPreviousAgent(projectId, allocated.apiPort, allocated.devPort);
     await new Promise((r) => setTimeout(r, 50));
     progress("fetching-files", "Fetching project files...");
@@ -28351,7 +29140,7 @@ async function startAdditionalProject(projectId, opts) {
       localServer.markSynced(fetchedVersionId);
     }
     const installer = new PackageInstaller({ projectDir });
-    const needsInstall = !installer.areDependenciesInstalled() && fs16.existsSync(path15.join(projectDir, "package.json"));
+    const needsInstall = !installer.areDependenciesInstalled() && fs17.existsSync(path16.join(projectDir, "package.json"));
     if (needsInstall) {
       const installStart = Date.now();
       console.log(source_default.gray(`  Installing dependencies...`));
@@ -28462,13 +29251,13 @@ async function statusCommand() {
 
 // dist/commands/service.js
 init_config();
-import fs17 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import os11 from "os";
 import { execSync as execSync3 } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename_esm = fileURLToPath2(import.meta.url);
-var __dirname_esm = path16.dirname(__filename_esm);
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename_esm2 = fileURLToPath3(import.meta.url);
+var __dirname_esm2 = path17.dirname(__filename_esm2);
 var PLIST_LABEL = "com.nstantpage.agent";
 var SYSTEMD_SERVICE = "nstantpage-agent";
 var WIN_TASK_NAME = "NstantpageAgent";
@@ -28495,8 +29284,8 @@ async function serviceStopCommand() {
   const platform2 = os11.platform();
   let stopped = false;
   if (platform2 === "darwin") {
-    const plistPath = path16.join(os11.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    if (fs17.existsSync(plistPath)) {
+    const plistPath = path17.join(os11.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+    if (fs18.existsSync(plistPath)) {
       try {
         execSync3(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: "utf-8" });
         console.log(source_default.green("  \u2713 Background service stopped"));
@@ -28557,7 +29346,7 @@ async function serviceInstallCommand(options = {}) {
     return;
   }
   if (electronAppPath === null) {
-    console.log(source_default.gray("  Tip: Install the nstantpage desktop app for a system tray icon."));
+    console.log(source_default.gray('  Tip: Run "nstantpage update --desktop" to download the desktop app with tray icon.'));
   }
   if (platform2 === "darwin") {
     await installLaunchd(gateway, token);
@@ -28624,12 +29413,12 @@ async function serviceStatusCommand() {
   } else {
     console.log(source_default.gray("  Service status not available on this platform"));
   }
-  const logPath = path16.join(os11.homedir(), ".nstantpage", "agent.log");
-  if (fs17.existsSync(logPath)) {
-    const stats = fs17.statSync(logPath);
+  const logPath = path17.join(os11.homedir(), ".nstantpage", "agent.log");
+  if (fs18.existsSync(logPath)) {
+    const stats = fs18.statSync(logPath);
     console.log(source_default.gray(`  Log file:   ${logPath} (${(stats.size / 1024).toFixed(1)}KB)`));
     try {
-      const content = fs17.readFileSync(logPath, "utf-8");
+      const content = fs18.readFileSync(logPath, "utf-8");
       const lines = content.trim().split("\n").slice(-5);
       if (lines.length > 0) {
         console.log(source_default.gray("  Last log lines:"));
@@ -28643,35 +29432,39 @@ function findElectronApp() {
   const platform2 = os11.platform();
   if (platform2 === "darwin") {
     const candidates = [
+      // Downloaded by postinstall (npm i -g nstantpage-agent)
+      path17.join(os11.homedir(), ".nstantpage", "desktop", "nstantpage.app"),
       "/Applications/nstantpage.app",
-      path16.join(os11.homedir(), "Applications", "nstantpage.app"),
+      path17.join(os11.homedir(), "Applications", "nstantpage.app"),
       // Dev build location (from electron-builder --dir)
-      path16.join(__dirname_esm, "..", "..", "tray", "dist", "mac-arm64", "nstantpage.app"),
-      path16.join(__dirname_esm, "..", "..", "tray", "dist", "mac", "nstantpage.app")
+      path17.join(__dirname_esm2, "..", "..", "tray", "dist", "mac-arm64", "nstantpage.app"),
+      path17.join(__dirname_esm2, "..", "..", "tray", "dist", "mac", "nstantpage.app")
     ];
     for (const p of candidates) {
-      if (fs17.existsSync(p))
+      if (fs18.existsSync(p))
         return p;
     }
   } else if (platform2 === "win32") {
     const candidates = [
-      path16.join(os11.homedir(), "AppData", "Local", "Programs", "nstantpage", "nstantpage.exe"),
-      path16.join("C:\\Program Files", "nstantpage", "nstantpage.exe")
+      // Downloaded by postinstall (npm i -g nstantpage-agent)
+      path17.join(os11.homedir(), ".nstantpage", "desktop", "nstantpage.exe"),
+      path17.join(os11.homedir(), "AppData", "Local", "Programs", "nstantpage", "nstantpage.exe"),
+      path17.join("C:\\Program Files", "nstantpage", "nstantpage.exe")
     ];
     for (const p of candidates) {
-      if (fs17.existsSync(p))
+      if (fs18.existsSync(p))
         return p;
     }
   }
   return null;
 }
 async function installElectronLaunchd(appPath) {
-  const plistDir = path16.join(os11.homedir(), "Library", "LaunchAgents");
-  const plistPath = path16.join(plistDir, `${PLIST_LABEL}.plist`);
-  const logPath = path16.join(os11.homedir(), ".nstantpage", "agent.log");
-  const errPath = path16.join(os11.homedir(), ".nstantpage", "agent.err.log");
-  fs17.mkdirSync(plistDir, { recursive: true });
-  fs17.mkdirSync(path16.dirname(logPath), { recursive: true });
+  const plistDir = path17.join(os11.homedir(), "Library", "LaunchAgents");
+  const plistPath = path17.join(plistDir, `${PLIST_LABEL}.plist`);
+  const logPath = path17.join(os11.homedir(), ".nstantpage", "agent.log");
+  const errPath = path17.join(os11.homedir(), ".nstantpage", "agent.err.log");
+  fs18.mkdirSync(plistDir, { recursive: true });
+  fs18.mkdirSync(path17.dirname(logPath), { recursive: true });
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -28706,7 +29499,7 @@ async function installElectronLaunchd(appPath) {
     <integer>10</integer>
 </dict>
 </plist>`;
-  fs17.writeFileSync(plistPath, plist, "utf-8");
+  fs18.writeFileSync(plistPath, plist, "utf-8");
   try {
     execSync3(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: "utf-8" });
   } catch {
@@ -28723,8 +29516,8 @@ async function installElectronLaunchd(appPath) {
   console.log(source_default.blue("  Right-click the tray icon for options. Open nstantpage.com to connect projects.\n"));
 }
 async function installElectronWindowsTask(appPath) {
-  const logPath = path16.join(os11.homedir(), ".nstantpage", "agent.log");
-  fs17.mkdirSync(path16.dirname(logPath), { recursive: true });
+  const logPath = path17.join(os11.homedir(), ".nstantpage", "agent.log");
+  fs18.mkdirSync(path17.dirname(logPath), { recursive: true });
   try {
     execSync3(`schtasks /delete /tn "${WIN_TASK_NAME}" /f 2>nul`, { encoding: "utf-8" });
   } catch {
@@ -28753,8 +29546,8 @@ function getAgentBinPath() {
   }
   try {
     const npmRoot = execSync3("npm root -g", { encoding: "utf-8" }).trim();
-    const bin = path16.join(npmRoot, ".bin", "nstantpage");
-    if (fs17.existsSync(bin))
+    const bin = path17.join(npmRoot, ".bin", "nstantpage");
+    if (fs18.existsSync(bin))
       return bin;
   } catch {
   }
@@ -28770,12 +29563,12 @@ function getNodePath() {
 async function installLaunchd(gateway, token) {
   const binPath = getAgentBinPath();
   const nodePath = getNodePath();
-  const plistDir = path16.join(os11.homedir(), "Library", "LaunchAgents");
-  const plistPath = path16.join(plistDir, `${PLIST_LABEL}.plist`);
-  const logPath = path16.join(os11.homedir(), ".nstantpage", "agent.log");
-  const errPath = path16.join(os11.homedir(), ".nstantpage", "agent.err.log");
-  fs17.mkdirSync(plistDir, { recursive: true });
-  fs17.mkdirSync(path16.dirname(logPath), { recursive: true });
+  const plistDir = path17.join(os11.homedir(), "Library", "LaunchAgents");
+  const plistPath = path17.join(plistDir, `${PLIST_LABEL}.plist`);
+  const logPath = path17.join(os11.homedir(), ".nstantpage", "agent.log");
+  const errPath = path17.join(os11.homedir(), ".nstantpage", "agent.err.log");
+  fs18.mkdirSync(plistDir, { recursive: true });
+  fs18.mkdirSync(path17.dirname(logPath), { recursive: true });
   const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -28815,7 +29608,7 @@ async function installLaunchd(gateway, token) {
     <integer>-5</integer>
 </dict>
 </plist>`;
-  fs17.writeFileSync(plistPath, plist, "utf-8");
+  fs18.writeFileSync(plistPath, plist, "utf-8");
   try {
     execSync3(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: "utf-8" });
   } catch {
@@ -28831,8 +29624,8 @@ async function installLaunchd(gateway, token) {
   console.log(source_default.blue('  Open any project on nstantpage.com and click "Connect" to use it.\n'));
 }
 async function uninstallLaunchd() {
-  const plistPath = path16.join(os11.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-  if (!fs17.existsSync(plistPath)) {
+  const plistPath = path17.join(os11.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  if (!fs18.existsSync(plistPath)) {
     console.log(source_default.yellow("  \u26A0 Service is not installed"));
     return;
   }
@@ -28840,15 +29633,15 @@ async function uninstallLaunchd() {
     execSync3(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: "utf-8" });
   } catch {
   }
-  fs17.unlinkSync(plistPath);
+  fs18.unlinkSync(plistPath);
   console.log(source_default.green("  \u2713 Agent service uninstalled (launchd)"));
   console.log(source_default.gray("  The agent will no longer start automatically."));
 }
 async function installSystemd(gateway, token) {
   const binPath = getAgentBinPath();
-  const serviceDir = path16.join(os11.homedir(), ".config", "systemd", "user");
-  const servicePath = path16.join(serviceDir, `${SYSTEMD_SERVICE}.service`);
-  fs17.mkdirSync(serviceDir, { recursive: true });
+  const serviceDir = path17.join(os11.homedir(), ".config", "systemd", "user");
+  const servicePath = path17.join(serviceDir, `${SYSTEMD_SERVICE}.service`);
+  fs18.mkdirSync(serviceDir, { recursive: true });
   const unit = `[Unit]
 Description=nstantpage Local Development Agent
 After=network-online.target
@@ -28865,7 +29658,7 @@ Environment=HOME=${os11.homedir()}
 [Install]
 WantedBy=default.target
 `;
-  fs17.writeFileSync(servicePath, unit, "utf-8");
+  fs18.writeFileSync(servicePath, unit, "utf-8");
   try {
     execSync3("systemctl --user daemon-reload", { encoding: "utf-8" });
     execSync3(`systemctl --user enable ${SYSTEMD_SERVICE}`, { encoding: "utf-8" });
@@ -28884,8 +29677,8 @@ WantedBy=default.target
   console.log(source_default.blue('  Open any project on nstantpage.com and click "Connect" to use it.\n'));
 }
 async function uninstallSystemd() {
-  const servicePath = path16.join(os11.homedir(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
-  if (!fs17.existsSync(servicePath)) {
+  const servicePath = path17.join(os11.homedir(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+  if (!fs18.existsSync(servicePath)) {
     console.log(source_default.yellow("  \u26A0 Service is not installed"));
     return;
   }
@@ -28894,7 +29687,7 @@ async function uninstallSystemd() {
     execSync3(`systemctl --user disable ${SYSTEMD_SERVICE} 2>/dev/null`, { encoding: "utf-8" });
   } catch {
   }
-  fs17.unlinkSync(servicePath);
+  fs18.unlinkSync(servicePath);
   try {
     execSync3("systemctl --user daemon-reload", { encoding: "utf-8" });
   } catch {
@@ -28905,14 +29698,14 @@ async function uninstallSystemd() {
 async function installWindowsTask(gateway, token) {
   const binPath = getAgentBinPath();
   const nodePath = getNodePath();
-  const logPath = path16.join(os11.homedir(), ".nstantpage", "agent.log");
-  fs17.mkdirSync(path16.dirname(logPath), { recursive: true });
-  const batchDir = path16.join(os11.homedir(), ".nstantpage");
-  const batchPath = path16.join(batchDir, "agent-service.cmd");
+  const logPath = path17.join(os11.homedir(), ".nstantpage", "agent.log");
+  fs18.mkdirSync(path17.dirname(logPath), { recursive: true });
+  const batchDir = path17.join(os11.homedir(), ".nstantpage");
+  const batchPath = path17.join(batchDir, "agent-service.cmd");
   const batchContent = `@echo off\r
 "${nodePath}" "${binPath}" start --gateway ${gateway} --token ${token} >> "${logPath}" 2>&1\r
 `;
-  fs17.writeFileSync(batchPath, batchContent, "utf-8");
+  fs18.writeFileSync(batchPath, batchContent, "utf-8");
   try {
     execSync3(`schtasks /delete /tn "${WIN_TASK_NAME}" /f 2>nul`, { encoding: "utf-8" });
   } catch {
@@ -28942,21 +29735,148 @@ async function uninstallWindowsTask() {
   } catch {
     console.log(source_default.yellow("  \u26A0 Task is not installed or could not be removed"));
   }
-  const batchPath = path16.join(os11.homedir(), ".nstantpage", "agent-service.cmd");
+  const batchPath = path17.join(os11.homedir(), ".nstantpage", "agent-service.cmd");
   try {
-    if (fs17.existsSync(batchPath))
-      fs17.unlinkSync(batchPath);
+    if (fs18.existsSync(batchPath))
+      fs18.unlinkSync(batchPath);
   } catch {
   }
   console.log(source_default.gray("  The agent will no longer start automatically."));
 }
 
+// dist/commands/update.js
+import fs19 from "fs";
+import path18 from "path";
+import os12 from "os";
+import { execSync as execSync4 } from "child_process";
+var DESKTOP_DIR = path18.join(os12.homedir(), ".nstantpage", "desktop");
+var VERSION_FILE = path18.join(DESKTOP_DIR, ".version");
+async function updateCommand(options = {}) {
+  const updateBoth = !options.cli && !options.desktop;
+  const currentVersion = getPackageVersion();
+  console.log(source_default.blue(`
+  nstantpage v${currentVersion}
+`));
+  if (updateBoth || options.cli) {
+    await updateCli(currentVersion);
+  }
+  if (updateBoth || options.desktop) {
+    await updateDesktop();
+  }
+  console.log("");
+}
+async function updateCli(currentVersion) {
+  console.log(source_default.gray("  Checking npm for CLI updates..."));
+  try {
+    const latest = execSync4("npm view nstantpage-agent version 2>/dev/null", {
+      encoding: "utf-8"
+    }).trim();
+    if (latest === currentVersion) {
+      console.log(source_default.green(`  \u2713 CLI is up to date (${currentVersion})`));
+      return;
+    }
+    console.log(source_default.yellow(`  Updating CLI: ${currentVersion} \u2192 ${latest}`));
+    execSync4("npm install -g nstantpage-agent@latest", {
+      stdio: "inherit"
+    });
+    console.log(source_default.green(`  \u2713 CLI updated to ${latest}`));
+  } catch (err) {
+    console.log(source_default.red(`  \u2717 CLI update failed: ${err.message}`));
+    console.log(source_default.gray("  Try manually: npm install -g nstantpage-agent@latest"));
+  }
+}
+async function updateDesktop() {
+  console.log(source_default.gray("  Checking GitHub for desktop updates..."));
+  try {
+    const scriptPath = path18.join(path18.dirname(new URL(import.meta.url).pathname), "..", "..", "scripts", "postinstall.mjs");
+    if (fs19.existsSync(scriptPath)) {
+      execSync4(`node "${scriptPath}"`, { stdio: "inherit" });
+    } else {
+      const altPath = path18.join(path18.dirname(new URL(import.meta.url).pathname), "..", "scripts", "postinstall.mjs");
+      if (fs19.existsSync(altPath)) {
+        execSync4(`node "${altPath}"`, { stdio: "inherit" });
+      } else {
+        console.log(source_default.yellow("  \u26A0 Desktop updater script not found. Reinstall to fix: npm i -g nstantpage-agent"));
+      }
+    }
+  } catch (err) {
+    console.log(source_default.red(`  \u2717 Desktop update failed: ${err.message}`));
+  }
+}
+
+// dist/commands/run.js
+import fs20 from "fs";
+import path19 from "path";
+import os13 from "os";
+import { execSync as execSync5 } from "child_process";
+function findElectronApp2() {
+  const platform2 = os13.platform();
+  if (platform2 === "darwin") {
+    const candidates = [
+      path19.join(os13.homedir(), ".nstantpage", "desktop", "nstantpage.app"),
+      "/Applications/nstantpage.app",
+      path19.join(os13.homedir(), "Applications", "nstantpage.app")
+    ];
+    for (const p of candidates) {
+      if (fs20.existsSync(p))
+        return p;
+    }
+  } else if (platform2 === "win32") {
+    const candidates = [
+      path19.join(os13.homedir(), ".nstantpage", "desktop", "nstantpage.exe"),
+      path19.join(os13.homedir(), "AppData", "Local", "Programs", "nstantpage", "nstantpage.exe"),
+      path19.join("C:\\Program Files", "nstantpage", "nstantpage.exe")
+    ];
+    for (const p of candidates) {
+      if (fs20.existsSync(p))
+        return p;
+    }
+  }
+  return null;
+}
+async function runCommand(options = {}) {
+  const appPath = findElectronApp2();
+  if (!appPath) {
+    console.log(source_default.red("  \u2717 Desktop app not found."));
+    console.log(source_default.gray('  Run "nstantpage update --desktop" to download it.'));
+    process.exit(1);
+  }
+  const platform2 = os13.platform();
+  const extraArgs = [];
+  if (options.local !== void 0 && options.local !== false) {
+    const port = typeof options.local === "string" ? options.local : "5001";
+    extraArgs.push(`--local-url=http://localhost:${port}`);
+  }
+  console.log(source_default.blue(`
+  Opening nstantpage desktop app...`));
+  if (extraArgs.length) {
+    console.log(source_default.gray(`  Args: ${extraArgs.join(" ")}`));
+  }
+  try {
+    if (platform2 === "darwin") {
+      const argsStr = extraArgs.length ? ` --args ${extraArgs.join(" ")}` : "";
+      execSync5(`open -a "${appPath}"${argsStr}`, { stdio: "inherit" });
+    } else if (platform2 === "win32") {
+      const argsStr = extraArgs.join(" ");
+      execSync5(`"${appPath}" ${argsStr}`, { stdio: "inherit" });
+    } else {
+      console.log(source_default.yellow("  \u26A0 Desktop app not supported on this platform yet."));
+      process.exit(1);
+    }
+    console.log(source_default.green("  \u2713 App launched\n"));
+  } catch (err) {
+    console.log(source_default.red(`  \u2717 Failed to launch: ${err.message}`));
+    process.exit(1);
+  }
+}
+
 // dist/cli.js
 var program2 = new Command();
-program2.name("nstantpage").description("Local development agent for nstantpage.com \u2014 run projects on your machine, preview in the cloud").version("0.5.29");
+program2.name("nstantpage").description("Local development agent for nstantpage.com \u2014 run projects on your machine, preview in the cloud").version(getPackageVersion());
 program2.command("login").description("Authenticate with nstantpage.com").option("--gateway <url>", "Gateway URL (auto-detects local vs production)").option("--force", "Re-authenticate even if already logged in").action(loginCommand);
 program2.command("logout").description("Sign out and clear stored credentials").action(logoutCommand);
 program2.command("start").description("Start the agent for a project (replaces cloud containers)").argument("[directory]", "Project directory (defaults to ~/.nstantpage/projects/<id>)", ".").option("-p, --port <port>", "Local dev server port", "3000").option("-a, --api-port <port>", "Local API server port (internal)", "18924").option("--project-id <id>", "Link to a specific project ID").option("--gateway <url>", "Gateway URL (default: from login)").option("--backend <url>", "Backend API URL (auto-detected from gateway)").option("--token <token>", "Auth token (skip login flow)").option("--dir <path>", "Project directory override").option("--no-dev", "Skip starting the dev server (start manually later)").action(startCommand);
+program2.command("run").description("Open the nstantpage desktop app").option("--local [port]", "Connect to local backend (default: 5001)").action(runCommand);
 program2.command("stop").description("Stop the running agent").action(async () => {
   console.log(source_default.yellow("Stopping agent..."));
   const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -28982,4 +29902,5 @@ service.command("stop").description("Stop the running agent").action(serviceStop
 service.command("install").description("Install as a background service (auto-starts on boot)").option("--gateway <url>", "Gateway URL", "wss://webprev.live").action(serviceInstallCommand);
 service.command("uninstall").description("Remove the background service").action(serviceUninstallCommand);
 service.command("status").description("Check if the background service is running").action(serviceStatusCommand);
+program2.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);
 program2.parse();