nstantpage-agent 0.8.11 → 0.8.13

package/dist/commands/login.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import open from 'open';
 import http from 'http';
 import { getConfig } from '../config.js';
+import { serviceInstallCommand } from './service.js';
 /**
  * Resolve the frontend URL based on gateway.
  * - If gateway points to localhost → frontend is http://localhost:5001
@@ -178,6 +179,16 @@ export async function loginCommand(options = {}) {
     if (email)
         console.log(chalk.gray(`  Account: ${email}`));
     console.log(chalk.gray(`  Server:  ${isLocal ? 'localhost (dev)' : 'nstantpage.com'}`));
-    console.log(chalk.gray('  Run "nstantpage start" to connect your machine'));
+    // Auto-install background service with the new token
+    const gateway = conf.get('gatewayUrl') || 'wss://webprev.live';
+    try {
+        await serviceInstallCommand({ gateway });
+        console.log(chalk.green('  ✓ Agent is running as a background service.'));
+        console.log(chalk.gray('  Use "nstantpage logs" to view agent output.'));
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ⚠ Could not install background service: ${err.message}`));
+        console.log(chalk.gray('  Run "nstantpage run" to start manually.'));
+    }
 }
 //# sourceMappingURL=login.js.map

package/dist/commands/start.js

@@ -579,11 +579,13 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
                 existing.tunnel.disconnect();
                 await existing.localServer.stop();
                 activeProjects.delete(pid);
-                // Wipe the project directory
-                const projectDir = resolveProjectDir('.', pid);
-                if (fs.existsSync(projectDir)) {
-                    console.log(chalk.gray(`  Wiping project directory: ${projectDir}`));
-                    fs.rmSync(projectDir, { recursive: true, force: true });
+                // Wipe the project directory (only for non-LocalRepo)
+                if (!opts?.localFolderPath) {
+                    const projectDir = resolveProjectDir('.', pid);
+                    if (fs.existsSync(projectDir)) {
+                        console.log(chalk.gray(`  Wiping project directory: ${projectDir}`));
+                        fs.rmSync(projectDir, { recursive: true, force: true });
+                    }
                 }
             }
             else if (activeProjects.has(pid)) {
@@ -592,6 +594,7 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
             }
             const result = await startAdditionalProject(pid, {
                 token, backendUrl, gatewayUrl: options.gateway, deviceId, noDev: options.noDev,
+                localFolderPath: opts?.localFolderPath,
                 onProgress: (phase, message) => {
                     standbyTunnel.sendSetupProgress(pid, phase, message);
                 },
@@ -678,6 +681,7 @@ async function startStandbyMode(token, options, backendUrl, deviceId) {
         }
         const result = await startAdditionalProject(projectId, {
             token, backendUrl, gatewayUrl: options.gateway, deviceId, noDev: options.noDev,
+            localFolderPath: opts?.localFolderPath,
             onProgress: (phase, message) => {
                 standbyTunnel.sendSetupProgress(projectId, phase, message);
             },
@@ -736,29 +740,37 @@ async function startAdditionalProject(projectId, opts) {
     const progress = opts.onProgress || (() => { });
     const timings = {};
     const t0 = Date.now();
-    console.log(chalk.blue(`\n  📦 Starting project ${projectId}...`));
+    const isLocalRepo = !!opts.localFolderPath;
+    console.log(chalk.blue(`\n  📦 Starting project ${projectId}${isLocalRepo ? ' (LocalRepo)' : ''}...`));
     try {
         const allocated = allocatePortsForProject(projectId);
-        const projectDir = resolveProjectDir('.', projectId);
+        const projectDir = isLocalRepo ? opts.localFolderPath : resolveProjectDir('.', projectId);
         if (!fs.existsSync(projectDir))
             fs.mkdirSync(projectDir, { recursive: true });
         // Ensure ports are clear for this project before starting
         cleanupPreviousAgent(projectId, allocated.apiPort, allocated.devPort);
         await new Promise(r => setTimeout(r, 50));
         // ── Phase 1: API server + file fetch + tunnel connect (all parallel) ──
-        progress('fetching-files', 'Fetching project files...');
-        // Provision database if PostgreSQL is available
+        if (!isLocalRepo) {
+            progress('fetching-files', 'Fetching project files...');
+        }
+        else {
+            progress('starting-server', 'Starting local server...');
+        }
+        // Provision database if PostgreSQL is available (skip for LocalRepo)
         let databaseUrl = null;
-        try {
-            const hasPg = await probeLocalPostgres();
-            if (hasPg) {
-                databaseUrl = await ensureLocalProjectDb(projectId);
-                if (databaseUrl) {
-                    console.log(chalk.green(`  ✓ Database ready: project_${projectId}`));
+        if (!isLocalRepo) {
+            try {
+                const hasPg = await probeLocalPostgres();
+                if (hasPg) {
+                    databaseUrl = await ensureLocalProjectDb(projectId);
+                    if (databaseUrl) {
+                        console.log(chalk.green(`  ✓ Database ready: project_${projectId}`));
+                    }
                 }
             }
+            catch { }
         }
-        catch { }
         const serverEnv = {};
         if (databaseUrl)
             serverEnv['DATABASE_URL'] = databaseUrl;
@@ -799,17 +811,20 @@ async function startAdditionalProject(projectId, opts) {
                 tunnel.startBackgroundReconnect();
             }
         })();
+        // Fetch project files from backend (skip for LocalRepo — files are on disk)
         const fileStart = Date.now();
         let fetchedVersionId;
-        try {
-            const { versionId } = await fetchProjectFiles(opts.backendUrl, projectId, projectDir, opts.token);
-            fetchedVersionId = versionId;
-            timings['fetch-files'] = Date.now() - fileStart;
-            progress('fetching-files', `Files downloaded (${timings['fetch-files']}ms)`);
-        }
-        catch (err) {
-            console.log(chalk.yellow(`  ⚠ Could not fetch files: ${err.message}`));
-            progress('fetching-files', `Warning: ${err.message}`);
+        if (!isLocalRepo) {
+            try {
+                const { versionId } = await fetchProjectFiles(opts.backendUrl, projectId, projectDir, opts.token);
+                fetchedVersionId = versionId;
+                timings['fetch-files'] = Date.now() - fileStart;
+                progress('fetching-files', `Files downloaded (${timings['fetch-files']}ms)`);
+            }
+            catch (err) {
+                console.log(chalk.yellow(`  ⚠ Could not fetch files: ${err.message}`));
+                progress('fetching-files', `Warning: ${err.message}`);
+            }
         }
         // Write DATABASE_URL to .env AFTER file fetch (so it doesn't get overwritten)
         if (databaseUrl) {
@@ -822,49 +837,51 @@ async function startAdditionalProject(projectId, opts) {
         if (fetchedVersionId) {
             localServer.markSynced(fetchedVersionId);
         }
-        // ── Phase 2: Install deps (if needed) ────────────────────────────
-        const installer = new PackageInstaller({ projectDir });
-        const needsInstall = !installer.areDependenciesInstalled() && fs.existsSync(path.join(projectDir, 'package.json'));
-        if (needsInstall) {
-            const installStart = Date.now();
-            console.log(chalk.gray(`  Installing dependencies...`));
-            progress('installing-deps', 'Installing npm dependencies...');
-            try {
-                await installer.ensureDependencies();
-                timings['install'] = Date.now() - installStart;
-                console.log(chalk.green(`  ✓ Dependencies installed (${timings['install']}ms)`));
-                progress('installing-deps', `Dependencies installed (${timings['install']}ms)`);
-            }
-            catch (err) {
-                timings['install'] = Date.now() - installStart;
-                console.log(chalk.red(`  ✗ Install failed: ${err.message}`));
-                console.log(chalk.yellow(`  ⚠ Dev server may fail — retrying install on first request`));
-                progress('installing-deps', `Install failed: ${err.message}`);
-            }
-        }
-        else {
-            progress('installing-deps', 'Dependencies already installed (cached)');
-        }
-        // ── Phase 3: Start dev server ────────────────────────────────────
-        if (!opts.noDev) {
-            if (installer.areDependenciesInstalled()) {
-                progress('starting-dev', 'Starting dev server...');
+        // ── Phase 2: Install deps (if needed) — skip for LocalRepo ──
+        if (!isLocalRepo) {
+            const installer = new PackageInstaller({ projectDir });
+            const needsInstall = !installer.areDependenciesInstalled() && fs.existsSync(path.join(projectDir, 'package.json'));
+            if (needsInstall) {
+                const installStart = Date.now();
+                console.log(chalk.gray(`  Installing dependencies...`));
+                progress('installing-deps', 'Installing npm dependencies...');
                 try {
-                    const devStart = Date.now();
-                    await localServer.getDevServer().start();
-                    timings['dev-server'] = Date.now() - devStart;
-                    console.log(chalk.green(`  ✓ Dev server on port ${allocated.devPort} (${timings['dev-server']}ms)`));
-                    progress('starting-dev', `Dev server on port ${allocated.devPort}`);
+                    await installer.ensureDependencies();
+                    timings['install'] = Date.now() - installStart;
+                    console.log(chalk.green(`  ✓ Dependencies installed (${timings['install']}ms)`));
+                    progress('installing-deps', `Dependencies installed (${timings['install']}ms)`);
                 }
                 catch (err) {
-                    console.log(chalk.yellow(`  ⚠ Dev server: ${err.message}`));
-                    progress('starting-dev', `Warning: ${err.message}`);
+                    timings['install'] = Date.now() - installStart;
+                    console.log(chalk.red(`  ✗ Install failed: ${err.message}`));
+                    console.log(chalk.yellow(`  ⚠ Dev server may fail — retrying install on first request`));
+                    progress('installing-deps', `Install failed: ${err.message}`);
                 }
             }
             else {
-                console.log(chalk.yellow(`  ⚠ Skipping dev server — dependencies not installed`));
-                console.log(chalk.gray(`    Dev server will start when browser opens the project`));
-                progress('starting-dev', 'Skipped — dependencies not installed');
+                progress('installing-deps', 'Dependencies already installed (cached)');
+            }
+            // ── Phase 3: Start dev server — skip for LocalRepo ──
+            if (!opts.noDev) {
+                if (installer.areDependenciesInstalled()) {
+                    progress('starting-dev', 'Starting dev server...');
+                    try {
+                        const devStart = Date.now();
+                        await localServer.getDevServer().start();
+                        timings['dev-server'] = Date.now() - devStart;
+                        console.log(chalk.green(`  ✓ Dev server on port ${allocated.devPort} (${timings['dev-server']}ms)`));
+                        progress('starting-dev', `Dev server on port ${allocated.devPort}`);
+                    }
+                    catch (err) {
+                        console.log(chalk.yellow(`  ⚠ Dev server: ${err.message}`));
+                        progress('starting-dev', `Warning: ${err.message}`);
+                    }
+                }
+                else {
+                    console.log(chalk.yellow(`  ⚠ Skipping dev server — dependencies not installed`));
+                    console.log(chalk.gray(`    Dev server will start when browser opens the project`));
+                    progress('starting-dev', 'Skipped — dependencies not installed');
+                }
             }
         }
         // Ensure tunnel is connected before declaring ready

package/dist/commands/status.d.ts

@@ -1,4 +1,9 @@
 /**
- * Status command — show agent connection status
+ * Status command — show agent connection status.
+ *
+ * Checks three sources:
+ * 1. Status server at localhost:18999 (most accurate — shows live tunnel state)
+ * 2. OS service (launchd on macOS, systemd on Linux)
+ * 3. Stored config (auth, gateway)
  */
 export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -1,53 +1,103 @@
 /**
- * Status command — show agent connection status
+ * Status command — show agent connection status.
+ *
+ * Checks three sources:
+ * 1. Status server at localhost:18999 (most accurate — shows live tunnel state)
+ * 2. OS service (launchd on macOS, systemd on Linux)
+ * 3. Stored config (auth, gateway)
  */
 import chalk from 'chalk';
+import os from 'os';
+import { execSync } from 'child_process';
 import { getConfig } from '../config.js';
+import { getPackageVersion } from '../version.js';
+const STATUS_PORT = 18999;
+async function fetchAgentStatus() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch(`http://localhost:${STATUS_PORT}/status`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+function checkOsService() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        try {
+            const result = execSync('launchctl list | grep com.nstantpage.agent', { encoding: 'utf-8' }).trim();
+            if (result) {
+                const pid = result.split('\t')[0];
+                return { installed: true, pid: pid !== '-' ? pid : undefined };
+            }
+        }
+        catch { }
+    }
+    else if (platform === 'linux') {
+        try {
+            const result = execSync('systemctl --user is-active nstantpage-agent 2>/dev/null', { encoding: 'utf-8' }).trim();
+            return { installed: true, pid: result === 'active' ? 'active' : undefined };
+        }
+        catch { }
+    }
+    return { installed: false };
+}
+function formatUptime(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m`;
+}
 export async function statusCommand() {
     const conf = getConfig();
     const token = conf.get('token');
-    const projectId = conf.get('projectId');
-    const pid = conf.get('agentPid');
-    const lastConnected = conf.get('lastConnected');
-    const devPort = conf.get('devPort') || 3000;
-    const apiPort = conf.get('apiPort') || 18924;
-    console.log(chalk.blue('\n  nstantpage agent v0.2.0\n'));
+    const email = conf.get('email');
+    const gateway = conf.get('gatewayUrl') || 'wss://webprev.live';
+    const isLocal = /^wss?:\/\/(localhost|127\.0\.0\.1)/.test(gateway);
+    console.log(chalk.blue(`\n  nstantpage agent v${getPackageVersion()}\n`));
     // Auth
     if (token) {
-        console.log(chalk.green('  ✓ Authenticated'));
+        console.log(chalk.green(`  ✓ Authenticated${email ? ` (${email})` : ''}`));
     }
     else {
         console.log(chalk.red('  ✗ Not authenticated (run "nstantpage login")'));
     }
-    // Project
-    if (projectId) {
-        console.log(chalk.gray(`  Project:    ${projectId}`));
-        console.log(chalk.gray(`  Preview:    https://${projectId}.webprev.live`));
-    }
-    else {
-        console.log(chalk.gray('  No project linked'));
-    }
-    // Running
-    if (pid) {
-        try {
-            process.kill(pid, 0); // Check if process exists
-            console.log(chalk.green(`  ✓ Agent running (PID ${pid})`));
-            console.log(chalk.gray(`    Dev server: http://localhost:${devPort}`));
-            console.log(chalk.gray(`    API server: http://localhost:${apiPort}`));
+    console.log(chalk.gray(`  Server:     ${isLocal ? 'localhost (dev)' : 'nstantpage.com'}`));
+    // Try live status from the status server
+    const live = await fetchAgentStatus();
+    const service = checkOsService();
+    if (live) {
+        console.log(chalk.green(`  ✓ Agent running`));
+        console.log(chalk.gray(`    Tunnel:   ${live.tunnelStatus}`));
+        console.log(chalk.gray(`    Uptime:   ${formatUptime(live.uptime)}`));
+        console.log(chalk.gray(`    Gateway:  ${live.gatewayUrl}`));
+        if (live.activeProjects.length > 0) {
+            console.log(chalk.gray(`    Projects: ${live.activeProjects.map(p => p.projectId).join(', ')}`));
+        }
+        else {
+            console.log(chalk.gray(`    Projects: none (standby mode)`));
         }
-        catch {
-            console.log(chalk.gray('  Agent not running'));
-            conf.delete('agentPid');
+    }
+    else if (service.installed) {
+        console.log(chalk.yellow(`  ⚠ Service installed but agent not responding`));
+        if (service.pid) {
+            console.log(chalk.gray(`    PID: ${service.pid}`));
         }
+        console.log(chalk.gray('    Try: nstantpage logs'));
     }
     else {
         console.log(chalk.gray('  Agent not running'));
+        console.log(chalk.gray('  Run "nstantpage run" to start'));
     }
-    // Last connected
-    if (lastConnected) {
-        console.log(chalk.gray(`  Last connected: ${lastConnected}`));
-    }
-    console.log(chalk.gray(`\n  Mode: Agent (replaces cloud containers)`));
     console.log('');
 }
 //# sourceMappingURL=status.js.map

package/dist/tunnel.d.ts

@@ -27,6 +27,7 @@ interface TunnelClientOptions {
     /** Callback when gateway requests starting a new project on this device */
     onStartProject?: (projectId: string, options?: {
         clean?: boolean;
+        localFolderPath?: string;
     }) => Promise<void>;
     /** Callback for setup progress — lets the standby tunnel relay phases to gateway */
     onSetupProgress?: (projectId: string, phase: string, message: string) => void;

package/dist/tunnel.js

@@ -403,8 +403,8 @@ export class TunnelClient {
      * Handle start-project: gateway wants this agent to start serving a new project.
      * Called when user clicks "Connect" in the web editor's Cloud panel.
      */
-    async handleStartProject(projectId, clean) {
-        console.log(`  [Tunnel] Received start-project command for ${projectId}${clean ? ' (clean)' : ''}`);
+    async handleStartProject(projectId, clean, localFolderPath) {
+        console.log(`  [Tunnel] Received start-project command for ${projectId}${clean ? ' (clean)' : ''}${localFolderPath ? ` (local: ${localFolderPath})` : ''}`);
         if (!projectId) {
             this.send({ type: 'start-project-result', success: false, error: 'Missing projectId' });
             return;
@@ -413,7 +413,7 @@ export class TunnelClient {
             try {
                 // Send initial progress
                 this.sendSetupProgress(projectId, 'starting', 'Starting project setup...');
-                await this.options.onStartProject(projectId, clean ? { clean: true } : undefined);
+                await this.options.onStartProject(projectId, { ...(clean ? { clean: true } : {}), ...(localFolderPath ? { localFolderPath } : {}) });
                 this.sendSetupProgress(projectId, 'ready', 'Project is live!');
                 this.send({ type: 'start-project-result', projectId, success: true });
             }
@@ -474,7 +474,7 @@ export class TunnelClient {
                 this.handleWsClose(msg.wsId);
                 break;
             case 'start-project':
-                this.handleStartProject(msg.projectId, msg.clean);
+                this.handleStartProject(msg.projectId, msg.clean, msg.localFolderPath);
                 break;
             case 'force-disconnect':
                 console.log('  [Tunnel] Received force-disconnect — will not reconnect');

package/package.json

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