nstantpage-agent 0.4.0 → 0.4.2

package/dist/cli.d.ts

@@ -7,6 +7,8 @@
  *   nstantpage start [dir]        — Start agent for a project directory
  *   nstantpage stop               — Stop running agent
  *   nstantpage status             — Show agent status
+ *   nstantpage service            — Install as background service (auto-start on boot)
+ *   nstantpage service --uninstall — Remove background service
  *
  * The agent replaces Docker containers — your project runs natively on your
  * machine with full performance, and the cloud editor connects through a tunnel.

package/dist/cli.js

@@ -7,6 +7,8 @@
  *   nstantpage start [dir]        — Start agent for a project directory
  *   nstantpage stop               — Stop running agent
  *   nstantpage status             — Show agent status
+ *   nstantpage service            — Install as background service (auto-start on boot)
+ *   nstantpage service --uninstall — Remove background service
  *
  * The agent replaces Docker containers — your project runs natively on your
  * machine with full performance, and the cloud editor connects through a tunnel.
@@ -16,6 +18,7 @@ import chalk from 'chalk';
 import { loginCommand } from './commands/login.js';
 import { startCommand } from './commands/start.js';
 import { statusCommand } from './commands/status.js';
+import { serviceCommand } from './commands/service.js';
 const program = new Command();
 program
     .name('nstantpage')
@@ -66,5 +69,12 @@ program
     .command('status')
     .description('Show agent status')
     .action(statusCommand);
+program
+    .command('service')
+    .description('Install/uninstall agent as a background service (starts on boot)')
+    .option('--project-id <id>', 'Project ID to serve')
+    .option('--gateway <url>', 'Gateway URL', 'wss://webprev.live')
+    .option('--uninstall', 'Remove the background service')
+    .action(serviceCommand);
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/commands/service.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Service command — install/uninstall the nstantpage agent as a background service.
+ *
+ * macOS:   Uses launchd (~/Library/LaunchAgents/com.nstantpage.agent.plist)
+ * Linux:   Uses systemd (--user mode: ~/.config/systemd/user/nstantpage-agent.service)
+ * Windows: Uses node-windows / Task Scheduler (future)
+ *
+ * This allows the agent to run on boot, always ready to accept connections
+ * from the web editor without manually starting it each time.
+ */
+interface ServiceOptions {
+    projectId?: string;
+    gateway?: string;
+    uninstall?: boolean;
+}
+export declare function serviceCommand(options: ServiceOptions): Promise<void>;
+export {};

package/dist/commands/service.js

@@ -0,0 +1,215 @@
+/**
+ * Service command — install/uninstall the nstantpage agent as a background service.
+ *
+ * macOS:   Uses launchd (~/Library/LaunchAgents/com.nstantpage.agent.plist)
+ * Linux:   Uses systemd (--user mode: ~/.config/systemd/user/nstantpage-agent.service)
+ * Windows: Uses node-windows / Task Scheduler (future)
+ *
+ * This allows the agent to run on boot, always ready to accept connections
+ * from the web editor without manually starting it each time.
+ */
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { getConfig } from '../config.js';
+const PLIST_LABEL = 'com.nstantpage.agent';
+const SYSTEMD_SERVICE = 'nstantpage-agent';
+export async function serviceCommand(options) {
+    if (options.uninstall) {
+        return uninstallService();
+    }
+    return installService(options);
+}
+function getAgentBinPath() {
+    // Find the globally installed nstantpage binary
+    try {
+        const resolved = execSync('which nstantpage 2>/dev/null || which nstantpage-agent 2>/dev/null', { encoding: 'utf-8' }).trim();
+        if (resolved)
+            return resolved;
+    }
+    catch { }
+    // Fallback: try npm root -g
+    try {
+        const npmRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+        const bin = path.join(npmRoot, '.bin', 'nstantpage');
+        if (fs.existsSync(bin))
+            return bin;
+    }
+    catch { }
+    throw new Error('Could not find nstantpage binary. Install globally first: npm install -g nstantpage-agent');
+}
+function getNodePath() {
+    try {
+        return execSync('which node', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return '/usr/local/bin/node';
+    }
+}
+async function installService(options) {
+    const conf = getConfig();
+    const token = conf.get('token');
+    if (!token) {
+        console.log(chalk.red('✗ Not authenticated. Run "nstantpage login" first.'));
+        process.exit(1);
+    }
+    const projectId = options.projectId;
+    if (!projectId) {
+        console.log(chalk.red('✗ --project-id is required for service mode.'));
+        console.log(chalk.gray('  Example: nstantpage service --project-id 1234'));
+        process.exit(1);
+    }
+    const gateway = options.gateway || 'wss://webprev.live';
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        await installLaunchd(projectId, gateway, token);
+    }
+    else if (platform === 'linux') {
+        await installSystemd(projectId, gateway, token);
+    }
+    else {
+        console.log(chalk.yellow('⚠ Background service not yet supported on this platform.'));
+        console.log(chalk.gray('  Use "nstantpage start" to run manually.'));
+        console.log(chalk.gray('  Windows support coming soon.'));
+        process.exit(1);
+    }
+}
+async function installLaunchd(projectId, gateway, token) {
+    const binPath = getAgentBinPath();
+    const nodePath = getNodePath();
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    const plistPath = path.join(plistDir, `${PLIST_LABEL}.plist`);
+    const logPath = path.join(os.homedir(), '.nstantpage', 'agent.log');
+    const errPath = path.join(os.homedir(), '.nstantpage', 'agent.err.log');
+    // Ensure dirs exist
+    fs.mkdirSync(plistDir, { recursive: true });
+    fs.mkdirSync(path.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">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${binPath}</string>
+        <string>start</string>
+        <string>--project-id</string>
+        <string>${projectId}</string>
+        <string>--gateway</string>
+        <string>${gateway}</string>
+        <string>--token</string>
+        <string>${token}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${logPath}</string>
+    <key>StandardErrorPath</key>
+    <string>${errPath}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plist, 'utf-8');
+    // Unload if already running
+    try {
+        execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: 'utf-8' });
+    }
+    catch { }
+    // Load
+    execSync(`launchctl load "${plistPath}"`, { encoding: 'utf-8' });
+    console.log(chalk.green('\n  ✓ Agent installed as background service (launchd)\n'));
+    console.log(chalk.gray(`  Plist:    ${plistPath}`));
+    console.log(chalk.gray(`  Project:  ${projectId}`));
+    console.log(chalk.gray(`  Log:      ${logPath}`));
+    console.log(chalk.gray(`  Status:   launchctl list | grep nstantpage`));
+    console.log(chalk.gray(`  Stop:     nstantpage service --uninstall\n`));
+    console.log(chalk.blue('  The agent will now start automatically on login.'));
+}
+async function installSystemd(projectId, gateway, token) {
+    const binPath = getAgentBinPath();
+    const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    const servicePath = path.join(serviceDir, `${SYSTEMD_SERVICE}.service`);
+    fs.mkdirSync(serviceDir, { recursive: true });
+    const unit = `[Unit]
+Description=nstantpage Local Development Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${binPath} start --project-id ${projectId} --gateway ${gateway} --token ${token}
+Restart=on-failure
+RestartSec=10
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+Environment=HOME=${os.homedir()}
+
+[Install]
+WantedBy=default.target
+`;
+    fs.writeFileSync(servicePath, unit, 'utf-8');
+    try {
+        execSync('systemctl --user daemon-reload', { encoding: 'utf-8' });
+        execSync(`systemctl --user enable ${SYSTEMD_SERVICE}`, { encoding: 'utf-8' });
+        execSync(`systemctl --user start ${SYSTEMD_SERVICE}`, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ⚠ systemctl commands failed: ${err.message}`));
+        console.log(chalk.gray('  You may need to reload manually: systemctl --user daemon-reload'));
+    }
+    console.log(chalk.green('\n  ✓ Agent installed as background service (systemd --user)\n'));
+    console.log(chalk.gray(`  Unit:     ${servicePath}`));
+    console.log(chalk.gray(`  Project:  ${projectId}`));
+    console.log(chalk.gray(`  Status:   systemctl --user status ${SYSTEMD_SERVICE}`));
+    console.log(chalk.gray(`  Logs:     journalctl --user -u ${SYSTEMD_SERVICE} -f`));
+    console.log(chalk.gray(`  Stop:     nstantpage service --uninstall\n`));
+    console.log(chalk.blue('  The agent will now start automatically on login.'));
+}
+async function uninstallService() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+        try {
+            execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { encoding: 'utf-8' });
+        }
+        catch { }
+        if (fs.existsSync(plistPath)) {
+            fs.unlinkSync(plistPath);
+        }
+        console.log(chalk.green('  ✓ Agent service uninstalled (launchd)'));
+    }
+    else if (platform === 'linux') {
+        try {
+            execSync(`systemctl --user stop ${SYSTEMD_SERVICE} 2>/dev/null`, { encoding: 'utf-8' });
+            execSync(`systemctl --user disable ${SYSTEMD_SERVICE} 2>/dev/null`, { encoding: 'utf-8' });
+        }
+        catch { }
+        const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', `${SYSTEMD_SERVICE}.service`);
+        if (fs.existsSync(servicePath)) {
+            fs.unlinkSync(servicePath);
+            try {
+                execSync('systemctl --user daemon-reload', { encoding: 'utf-8' });
+            }
+            catch { }
+        }
+        console.log(chalk.green('  ✓ Agent service uninstalled (systemd)'));
+    }
+    else {
+        console.log(chalk.yellow('  ⚠ Service uninstall not supported on this platform'));
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/commands/start.js

@@ -24,18 +24,18 @@ import { getConfig, getProjectConfig, setProjectConfig, clearProjectConfig, getD
 import { TunnelClient } from '../tunnel.js';
 import { LocalServer } from '../localServer.js';
 import { PackageInstaller } from '../packageInstaller.js';
-const VERSION = '0.4.0';
+const VERSION = '0.4.1';
 /**
  * Resolve the backend API base URL.
  * - If --backend is passed, use it
  * - If gateway is local (ws://localhost), assume backend is localhost:5001
- * - Otherwise, default to https://ntstantpage.com
+ * - Otherwise, default to https://nstantpage.com
  */
 function resolveBackendUrl(options) {
     if (options.backend)
         return options.backend.replace(/\/$/, '');
     const isLocal = /^wss?:\/\/(localhost|127\.0\.0\.1)/.test(options.gateway);
-    return isLocal ? 'http://localhost:5001' : 'https://ntstantpage.com';
+    return isLocal ? 'http://localhost:5001' : 'https://nstantpage.com';
 }
 /**
  * Resolve project directory:

package/dist/localServer.d.ts

@@ -46,6 +46,10 @@ export declare class LocalServer {
     private handleInstall;
     private handleExec;
     private handleTerminal;
+    private handleTerminalSessions;
+    private handleTerminalWrite;
+    private handleTerminalResize;
+    private handleAgentStatus;
     private handleContainerStatus;
     private handleContainerStats;
     private handleLogs;

package/dist/localServer.js

@@ -14,11 +14,16 @@
  */
 import http from 'http';
 import os from 'os';
+import { spawn } from 'child_process';
 import { DevServer } from './devServer.js';
 import { FileManager } from './fileManager.js';
 import { Checker } from './checker.js';
 import { ErrorStore, structuredErrorToString } from './errorStore.js';
 import { PackageInstaller } from './packageInstaller.js';
+const terminalSessions = new Map();
+function generateSessionId() {
+    return Math.random().toString(16).slice(2, 10);
+}
 export class LocalServer {
     server = null;
     options;
@@ -113,6 +118,10 @@ export class LocalServer {
             '/live/install': this.handleInstall,
             '/live/exec': this.handleExec,
             '/live/terminal': this.handleTerminal,
+            '/live/terminal/sessions': this.handleTerminalSessions,
+            '/live/terminal/write': this.handleTerminalWrite,
+            '/live/terminal/resize': this.handleTerminalResize,
+            '/live/agent-status': this.handleAgentStatus,
             '/live/container-status': this.handleContainerStatus,
             '/live/container-stats': this.handleContainerStats,
             '/live/logs': this.handleLogs,
@@ -286,6 +295,144 @@ export class LocalServer {
             stderr: result.stderr,
         });
     }
+    // ─── /live/terminal/sessions ─────────────────────────────────
+    async handleTerminalSessions(req, res, body, url) {
+        const method = req.method?.toUpperCase() || 'GET';
+        // GET → list sessions for this project
+        if (method === 'GET') {
+            const sessions = Array.from(terminalSessions.values())
+                .filter(s => s.projectId === this.options.projectId)
+                .map(s => ({
+                sessionId: s.id,
+                projectId: s.projectId,
+                createdAt: s.createdAt,
+                lastActivity: s.lastActivity,
+                cols: s.cols,
+                rows: s.rows,
+                isAiSession: s.isAiSession,
+            }));
+            this.json(res, { success: true, sessions });
+            return;
+        }
+        // POST → create a new terminal session
+        if (method !== 'POST') {
+            res.statusCode = 405;
+            this.json(res, { error: 'Method not allowed' });
+            return;
+        }
+        let parsed = {};
+        try {
+            parsed = body ? JSON.parse(body) : {};
+        }
+        catch { }
+        const sessionId = generateSessionId();
+        const cols = parsed.cols || 120;
+        const rows = parsed.rows || 30;
+        const isAiSession = parsed.isAiSession || false;
+        // Determine shell
+        const shellCmd = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/bash');
+        const shell = spawn(shellCmd, [], {
+            cwd: this.options.projectDir,
+            env: { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const session = {
+            id: sessionId,
+            projectId: this.options.projectId,
+            shell,
+            outputBuffer: [],
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+            cols,
+            rows,
+            isAiSession,
+        };
+        shell.stdout?.on('data', (data) => {
+            session.outputBuffer.push(data.toString('utf-8'));
+            session.lastActivity = Date.now();
+            // Keep buffer capped at ~100KB
+            while (session.outputBuffer.length > 500)
+                session.outputBuffer.shift();
+        });
+        shell.stderr?.on('data', (data) => {
+            session.outputBuffer.push(data.toString('utf-8'));
+            session.lastActivity = Date.now();
+            while (session.outputBuffer.length > 500)
+                session.outputBuffer.shift();
+        });
+        shell.on('exit', () => {
+            terminalSessions.delete(sessionId);
+        });
+        terminalSessions.set(sessionId, session);
+        this.json(res, {
+            success: true,
+            sessionId,
+            projectId: this.options.projectId,
+            cols,
+            rows,
+            isAiSession,
+        });
+    }
+    // ─── /live/terminal/write ────────────────────────────────────
+    async handleTerminalWrite(_req, res, body) {
+        let parsed = {};
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch { }
+        const { sessionId, data: inputData } = parsed;
+        if (!sessionId || !inputData) {
+            res.statusCode = 400;
+            this.json(res, { success: false, error: 'sessionId and data required' });
+            return;
+        }
+        const session = terminalSessions.get(sessionId);
+        if (!session) {
+            res.statusCode = 404;
+            this.json(res, { success: false, error: 'Session not found' });
+            return;
+        }
+        session.shell.stdin?.write(inputData);
+        session.lastActivity = Date.now();
+        this.json(res, { success: true });
+    }
+    // ─── /live/terminal/resize ───────────────────────────────────
+    async handleTerminalResize(_req, res, body) {
+        let parsed = {};
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch { }
+        const { sessionId, cols, rows } = parsed;
+        if (!sessionId) {
+            res.statusCode = 400;
+            this.json(res, { success: false, error: 'sessionId required' });
+            return;
+        }
+        const session = terminalSessions.get(sessionId);
+        if (!session) {
+            res.statusCode = 404;
+            this.json(res, { success: false, error: 'Session not found' });
+            return;
+        }
+        session.cols = cols || session.cols;
+        session.rows = rows || session.rows;
+        // For real pty we'd call pty.resize(cols, rows), but for child_process
+        // we just update the env (takes effect on next data)
+        this.json(res, { success: true, cols: session.cols, rows: session.rows });
+    }
+    // ─── /live/agent-status ──────────────────────────────────────
+    async handleAgentStatus(_req, res) {
+        this.json(res, {
+            connected: true,
+            projectId: this.options.projectId,
+            agent: {
+                version: '0.4.1',
+                hostname: os.hostname(),
+                platform: `${os.platform()} ${os.arch()}`,
+            },
+        });
+    }
     // ─── /live/container-status ──────────────────────────────────
     async handleContainerStatus(_req, res, _body, url) {
         this.json(res, {

package/package.json

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