@rexaray008/nodeproxy 1.0.1 → 2.0.0

package/bin/cli.js

@@ -3,6 +3,8 @@
 
 const { loadConfig, saveConfig, ensureConfig, DEFAULT_CONFIG_NAME } = require('../lib/config');
 const { startServer } = require('../lib/server');
+const cf = require('../lib/cloudflare');
+const pm2 = require('../lib/pm2');
 
 function usage() {
   console.log(`
@@ -12,9 +14,43 @@ Usage:
   nodeproxy start [--config <file>]        Start the proxy (auto-creates a
                                             default config on first run)
   nodeproxy init  [--config <file>]        Just create the config file
-  nodeproxy add <host> <target> [--config <file>]
+  nodeproxy add <host> <target> [--port <n>] [--config <file>]
                                             Add/update a route, e.g.
                                             nodeproxy add example.com http://localhost:4000
+                                            Targets the first listener unless
+                                            --port picks a specific one.
+  nodeproxy listen <port>  [--config <file>]
+                                            Add a brand new listener on a new
+                                            port, e.g. nodeproxy listen 9090
+                                            (then "nodeproxy add ... --port 9090")
+
+  nodeproxy tunnel setup --domain <domain> [--name <name>] [--port <n>]
+                                            One-time: install cloudflared if
+                                            needed, log in (opens a browser,
+                                            you click Authorize once), create
+                                            a tunnel, and point <domain> at
+                                            your local port (default 8080).
+  nodeproxy tunnel start [--name <name>]   Run just the tunnel.
+  nodeproxy tunnel doctor --domain <domain>
+                                            Diagnose "works locally but not
+                                            on other devices" issues.
+
+  nodeproxy app add <name> --cmd "<command>" [--cwd <dir>]
+                                            Register your own project to be
+                                            started/kept alive automatically
+                                            (via pm2), e.g.
+                                            nodeproxy app add myapp --cmd "npm start" --cwd ./my-project
+  nodeproxy app list                       Show registered/running apps.
+  nodeproxy app logs <name>                Tail logs for a registered app.
+  nodeproxy app stop <name>                Stop a registered app.
+
+  nodeproxy start [--config <file>] [--tunnel] [--name <name>]
+                                            Starts any registered apps (via
+                                            pm2), then the proxy, then the
+                                            tunnel if --tunnel is given.
+                                            This is the one command that
+                                            brings everything up together.
+
   nodeproxy help                           Show this message
 
 One-command quick start:
@@ -46,29 +82,192 @@ function main() {
   if (cmd === 'add') {
     const host = args[1];
     const target = args[2];
+    const portFlag = getFlag(args, '--port');
     if (!host || !target) {
-      console.error('Usage: nodeproxy add <host> <target>');
+      console.error('Usage: nodeproxy add <host> <target> [--port <n>]');
       process.exit(1);
     }
     const { config, file } = loadConfig(configPath);
-    const existing = config.routes.find(r => r.host === host);
+    const listener = portFlag
+      ? config.servers.find(s => String(s.port) === String(portFlag))
+      : config.servers[0];
+    if (!listener) {
+      console.error(`No listener on port ${portFlag}. Create one first with: nodeproxy listen ${portFlag}`);
+      process.exit(1);
+    }
+    const existing = listener.routes.find(r => r.host === host);
     if (existing) {
       existing.targets = [target];
     } else {
-      config.routes.push({ host, targets: [target], staticDir: null });
+      listener.routes.push({ host, targets: [target], staticDir: null });
+    }
+    saveConfig(config, configPath);
+    console.log(`[nodeproxy] Route added: ${host} -> ${target} on port ${listener.port} (${file})`);
+    return;
+  }
+
+  if (cmd === 'listen') {
+    const port = Number(args[1]);
+    if (!port) {
+      console.error('Usage: nodeproxy listen <port>');
+      process.exit(1);
+    }
+    const { config, file } = loadConfig(configPath);
+    if (config.servers.some(s => s.port === port)) {
+      console.error(`Port ${port} already has a listener.`);
+      process.exit(1);
     }
+    config.servers.push({
+      port,
+      https: { enabled: false, key: '', cert: '' },
+      routes: []
+    });
     saveConfig(config, configPath);
-    console.log(`[nodeproxy] Route added: ${host} -> ${target} (${file})`);
+    console.log(`[nodeproxy] New listener added on port ${port} (${file}). Now add routes to it with: nodeproxy add <host> <target> --port ${port}`);
     return;
   }
 
+  if (cmd === 'tunnel') {
+    const sub = args[1];
+    const domain = getFlag(args, '--domain');
+    const name = getFlag(args, '--name') || (domain ? domain.replace(/\./g, '-') : 'nodeproxy-tunnel');
+    const port = Number(getFlag(args, '--port')) || 8080;
+
+    if (sub === 'setup') {
+      if (!domain) {
+        console.error('Usage: nodeproxy tunnel setup --domain <yourdomain.com> [--name <name>] [--port <n>]');
+        console.error('(Your domain must already be added to your Cloudflare account.)');
+        process.exit(1);
+      }
+      if (!cf.ensureInstalled()) process.exit(1);
+      if (!cf.isLoggedIn()) {
+        cf.login();
+      } else {
+        console.log('[tunnel] Already logged in to Cloudflare on this machine.');
+      }
+      if (!cf.tunnelExists(name)) {
+        cf.createTunnel(name);
+      } else {
+        console.log(`[tunnel] Tunnel "${name}" already exists — reusing it.`);
+      }
+      const tunnelId = cf.getTunnelId(name);
+      cf.writeIngressConfig(name, tunnelId, domain, port);
+      cf.routeDns(name, domain);
+      console.log(`\n[tunnel] Done! "${domain}" now points at your local port ${port}.`);
+      console.log(`[tunnel] From now on, just run:  nodeproxy start --tunnel --name ${name}\n`);
+      return;
+    }
+
+    if (sub === 'start') {
+      cf.runTunnel(name);
+      return;
+    }
+
+    if (sub === 'doctor') {
+      if (!domain) {
+        console.error('Usage: nodeproxy tunnel doctor --domain <domain>');
+        process.exit(1);
+      }
+      cf.diagnose(domain).then(cf.printDiagnosis);
+      return;
+    }
+
+    console.error('Usage: nodeproxy tunnel setup --domain <domain>   |   nodeproxy tunnel start [--name <name>]   |   nodeproxy tunnel doctor --domain <domain>');
+    process.exit(1);
+  }
+
+  if (cmd === 'app') {
+    const sub = args[1];
+
+    if (sub === 'add') {
+      const name = args[2];
+      const appCmd = getFlag(args, '--cmd');
+      const cwd = getFlag(args, '--cwd');
+      if (!name || !appCmd) {
+        console.error('Usage: nodeproxy app add <name> --cmd "<command>" [--cwd <dir>]');
+        process.exit(1);
+      }
+      const { config, file } = loadConfig(configPath);
+      const existing = config.apps.find(a => a.name === name);
+      const entry = { name, cmd: appCmd, cwd: cwd || process.cwd() };
+      if (existing) {
+        Object.assign(existing, entry);
+      } else {
+        config.apps.push(entry);
+      }
+      saveConfig(config, configPath);
+      console.log(`[nodeproxy] Registered app "${name}" (${appCmd}) in ${file}`);
+      console.log('[nodeproxy] It will now start automatically with "nodeproxy start".');
+      return;
+    }
+
+    if (sub === 'list') {
+      const { config } = loadConfig(configPath);
+      if (config.apps.length === 0) {
+        console.log('No apps registered. Add one with: nodeproxy app add <name> --cmd "<command>"');
+        return;
+      }
+      const running = pm2.isInstalled() ? pm2.listApps() : [];
+      for (const a of config.apps) {
+        const proc = running.find(p => p.name === a.name);
+        const status = proc ? proc.pm2_env.status : 'not running';
+        console.log(`- ${a.name}: ${a.cmd} (${a.cwd}) [${status}]`);
+      }
+      return;
+    }
+
+    if (sub === 'stop') {
+      const name = args[2];
+      if (!name) {
+        console.error('Usage: nodeproxy app stop <name>');
+        process.exit(1);
+      }
+      pm2.stopApp(name);
+      return;
+    }
+
+    if (sub === 'logs') {
+      const name = args[2];
+      if (!name) {
+        console.error('Usage: nodeproxy app logs <name>');
+        process.exit(1);
+      }
+      pm2.logs(name);
+      return;
+    }
+
+    console.error('Usage: nodeproxy app add <name> --cmd "<command>" [--cwd <dir>]   |   list   |   stop <name>   |   logs <name>');
+    process.exit(1);
+  }
+
   if (cmd === 'start') {
     const { config, file } = loadConfig(configPath);
     console.log(`[nodeproxy] Using config: ${file}`);
     if (file.endsWith(DEFAULT_CONFIG_NAME)) {
       console.log('[nodeproxy] (edit this file, or use "nodeproxy add <host> <target>", to change routing)');
     }
+
+    if (config.apps && config.apps.length > 0) {
+      if (!pm2.ensureInstalled()) {
+        console.error('[nodeproxy] Could not set up pm2 — registered apps will not be started automatically.');
+      } else {
+        for (const app of config.apps) {
+          pm2.startApp(app);
+        }
+        pm2.save();
+      }
+    }
+
     startServer(config);
+
+    if (args.includes('--tunnel')) {
+      const name = getFlag(args, '--name') || 'nodeproxy-tunnel';
+      if (!cf.isInstalled()) {
+        console.error('[tunnel] cloudflared is not installed. Run "nodeproxy tunnel setup --domain <domain>" first.');
+        return;
+      }
+      cf.runTunnel(name);
+    }
     return;
   }
 

package/lib/cloudflare.js

@@ -0,0 +1,222 @@
+'use strict';
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CF_DIR = path.join(os.homedir(), '.cloudflared');
+
+function isInstalled() {
+  try {
+    execSync('cloudflared --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installInstructions() {
+  const platform = os.platform();
+  if (platform === 'darwin') {
+    return 'brew install cloudflared';
+  }
+  if (platform === 'linux') {
+    return [
+      '# Debian/Ubuntu (x86_64):',
+      'curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb -o cloudflared.deb && sudo dpkg -i cloudflared.deb',
+      '',
+      '# Or as a plain binary (any distro, x86_64):',
+      'sudo curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o /usr/local/bin/cloudflared && sudo chmod +x /usr/local/bin/cloudflared'
+    ].join('\n');
+  }
+  if (platform === 'win32') {
+    return 'winget install --id Cloudflare.cloudflared\n# or: choco install cloudflared';
+  }
+  return 'See https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/';
+}
+
+// Best-effort automatic install. Returns true on success.
+function tryAutoInstall() {
+  const platform = os.platform();
+  try {
+    if (platform === 'darwin') {
+      console.log('[tunnel] Installing cloudflared via Homebrew...');
+      execSync('brew install cloudflared', { stdio: 'inherit' });
+      return isInstalled();
+    }
+    if (platform === 'linux') {
+      console.log('[tunnel] Installing cloudflared binary to /usr/local/bin ...');
+      execSync(
+        'curl -fsSL https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o /tmp/cloudflared && ' +
+        'chmod +x /tmp/cloudflared && ' +
+        '(sudo mv /tmp/cloudflared /usr/local/bin/cloudflared || mv /tmp/cloudflared /usr/local/bin/cloudflared)',
+        { stdio: 'inherit' }
+      );
+      return isInstalled();
+    }
+  } catch (err) {
+    console.warn('[tunnel] Automatic install failed:', err.message);
+  }
+  return false;
+}
+
+function ensureInstalled() {
+  if (isInstalled()) return true;
+  console.log('[tunnel] cloudflared not found — attempting automatic install...');
+  if (tryAutoInstall()) {
+    console.log('[tunnel] cloudflared installed successfully.');
+    return true;
+  }
+  console.error('\n[tunnel] Could not auto-install cloudflared. Install it manually with:\n');
+  console.error(installInstructions());
+  console.error('\nThen re-run this command.\n');
+  return false;
+}
+
+function isLoggedIn() {
+  return fs.existsSync(path.join(CF_DIR, 'cert.pem'));
+}
+
+// Opens a browser for the one-time Cloudflare account authorization.
+// This step is inherently interactive (OAuth) and cannot be scripted away.
+function login() {
+  console.log('\n[tunnel] Opening your browser to authorize this machine with your Cloudflare account.');
+  console.log('[tunnel] (One-time step. After this, everything is fully automatic.)\n');
+  execSync('cloudflared tunnel login', { stdio: 'inherit' });
+}
+
+function tunnelExists(name) {
+  try {
+    const out = execSync('cloudflared tunnel list -o json', { encoding: 'utf8' });
+    const list = JSON.parse(out);
+    return list.some(t => t.name === name);
+  } catch {
+    return false;
+  }
+}
+
+function createTunnel(name) {
+  console.log(`[tunnel] Creating tunnel "${name}"...`);
+  execSync(`cloudflared tunnel create ${name}`, { stdio: 'inherit' });
+}
+
+function getTunnelId(name) {
+  const out = execSync('cloudflared tunnel list -o json', { encoding: 'utf8' });
+  const list = JSON.parse(out);
+  const match = list.find(t => t.name === name);
+  return match ? match.id : null;
+}
+
+function routeDns(name, domain) {
+  console.log(`[tunnel] Pointing ${domain} at tunnel "${name}"...`);
+  execSync(`cloudflared tunnel route dns ${name} ${domain}`, { stdio: 'inherit' });
+}
+
+// Writes the cloudflared ingress config that maps the public domain
+// to the local nodeproxy port.
+function writeIngressConfig(name, tunnelId, domain, localPort) {
+  const credFile = path.join(CF_DIR, `${tunnelId}.json`);
+  const configYml = [
+    `tunnel: ${tunnelId}`,
+    `credentials-file: ${credFile}`,
+    'ingress:',
+    `  - hostname: ${domain}`,
+    `    service: http://localhost:${localPort}`,
+    '  - service: http_status:404',
+    ''
+  ].join('\n');
+  const configPath = path.join(CF_DIR, `${name}.yml`);
+  fs.writeFileSync(configPath, configYml);
+  return configPath;
+}
+
+// Runs the tunnel as a background child process. Returns the child so
+// the caller can manage its lifecycle alongside the local proxy.
+function runTunnel(name) {
+  const configPath = path.join(CF_DIR, `${name}.yml`);
+  console.log(`[tunnel] Starting cloudflared tunnel "${name}"...`);
+  const child = spawn('cloudflared', ['tunnel', '--config', configPath, 'run', name], {
+    stdio: 'inherit'
+  });
+  child.on('exit', (code) => {
+    console.log(`[tunnel] cloudflared exited with code ${code}`);
+  });
+  return child;
+}
+
+const dns = require('dns').promises;
+
+// Diagnoses the single most common cause of "works on my machine but not
+// on other devices/networks": the DNS record Cloudflare created for the
+// tunnel is set to "DNS only" (grey cloud) instead of "Proxied" (orange
+// cloud). Tunnel hostnames only resolve publicly when proxied — an
+// unproxied record either fails to resolve for everyone else, or resolves
+// to an address only reachable from networks that already have a route to
+// it (which can look like "it works for me" if you're testing from
+// somewhere with cached/local resolution).
+async function diagnose(domain) {
+  const results = { domain, checks: [] };
+
+  let cname = null;
+  try {
+    const records = await dns.resolveCname(domain);
+    cname = records[0];
+    results.checks.push({ ok: true, label: 'CNAME record found', detail: cname });
+  } catch (err) {
+    results.checks.push({ ok: false, label: 'No CNAME record found', detail: err.code });
+  }
+
+  if (cname && !cname.includes('cfargotunnel.com')) {
+    results.checks.push({
+      ok: false,
+      label: 'CNAME does not point at a Cloudflare Tunnel',
+      detail: `Points at "${cname}" instead of a *.cfargotunnel.com address. Re-run "nodeproxy tunnel setup" to fix routing.`
+    });
+  }
+
+  try {
+    const addrs = await dns.resolve4(domain);
+    results.checks.push({ ok: true, label: 'Resolves to an IP address publicly', detail: addrs.join(', ') });
+    results.publiclyResolvable = true;
+  } catch (err) {
+    results.publiclyResolvable = false;
+    results.checks.push({
+      ok: false,
+      label: 'Does NOT resolve to an IP address publicly',
+      detail: `${err.code}. This is almost always because the DNS record is set to "DNS only" (grey cloud) in the Cloudflare dashboard instead of "Proxied" (orange cloud). Fix: Cloudflare dashboard → DNS → click the cloud icon next to this record so it turns orange, then wait ~1 minute and retry.`
+    });
+  }
+
+  return results;
+}
+
+function printDiagnosis(results) {
+  console.log(`\n[tunnel doctor] Checking ${results.domain} ...\n`);
+  for (const c of results.checks) {
+    console.log(`${c.ok ? '✓' : '✗'} ${c.label}${c.detail ? ` — ${c.detail}` : ''}`);
+  }
+  if (results.publiclyResolvable) {
+    console.log('\n[tunnel doctor] DNS looks correctly configured for public access.');
+    console.log('If it still only works on your own machine, check: is "nodeproxy start --tunnel" actually running right now? The tunnel only carries traffic while that process is alive.\n');
+  } else {
+    console.log('\n[tunnel doctor] This is why other devices can\'t reach it — see the fix above.\n');
+  }
+}
+
+module.exports = {
+  isInstalled,
+  ensureInstalled,
+  installInstructions,
+  isLoggedIn,
+  login,
+  tunnelExists,
+  createTunnel,
+  getTunnelId,
+  routeDns,
+  writeIngressConfig,
+  runTunnel,
+  diagnose,
+  printDiagnosis,
+  CF_DIR
+};

package/lib/config.js

@@ -7,34 +7,64 @@ const DEFAULT_CONFIG_NAME = 'nodeproxy.config.json';
 
 function defaultConfig() {
   return {
-    // Port the proxy itself listens on
-    port: 8080,
+    // Request logging to stdout (applies to all listeners)
+    logging: true,
 
-    // Optional HTTPS. Leave "enabled": false until you have real certs.
-    https: {
-      enabled: false,
-      port: 8443,
-      key: '',   // path to privkey.pem
-      cert: ''   // path to fullchain.pem
-    },
+    // Backend project(s) that nodeproxy will start and keep alive for you
+    // via pm2, so you don't have to manually run "npm start" yourself
+    // before the proxy has anything to forward to. Optional — leave this
+    // empty if you're already running your project some other way.
+    apps: [
+      // { "name": "myapp", "cmd": "npm start", "cwd": "/path/to/project" }
+    ],
 
-    // Request logging to stdout
-    logging: true,
+    // One entry per port you want the proxy to listen on.
+    // Each listener has its own independent set of host-based routes,
+    // so project A can live on 8080 and project B on 9090, fully
+    // separate from each other.
+    servers: [
+      {
+        port: 8080,
+        https: {
+          enabled: false,
+          key: '',   // path to privkey.pem
+          cert: ''   // path to fullchain.pem
+        },
+        // Virtual hosts / routes for THIS listener.
+        // "host" supports "*" as a catch-all for local testing.
+        // "targets" is a list -> automatic round-robin load balancing.
+        routes: [
+          {
+            host: '*',
+            targets: ['http://localhost:3000'],
+            // If set, static files are served from this directory when
+            // no upstream target responds (or as the sole behavior if
+            // targets is empty).
+            staticDir: null
+          }
+        ]
+      }
+    ]
+  };
+}
 
-    // Gzip/deflate pass-through is automatic (we just forward headers),
-    // nothing to configure there.
+// Accepts either the current multi-listener format ({ servers: [...] })
+// or the old single-listener format ({ port, https, routes }) and always
+// returns the multi-listener shape, so old config files keep working.
+function normalizeConfig(config) {
+  if (Array.isArray(config.servers)) {
+    if (!Array.isArray(config.apps)) config.apps = [];
+    return config;
+  }
 
-    // Virtual hosts / routes.
-    // "host" supports "*" as a catch-all for local testing.
-    // "targets" is a list -> automatic round-robin load balancing.
-    routes: [
+  return {
+    logging: config.logging !== false,
+    apps: Array.isArray(config.apps) ? config.apps : [],
+    servers: [
       {
-        host: '*',
-        targets: ['http://localhost:3000'],
-        // If set, static files are served from this directory when
-        // no upstream target responds (or as the sole behavior if
-        // targets is empty).
-        staticDir: null
+        port: config.port || 8080,
+        https: config.https || { enabled: false, key: '', cert: '' },
+        routes: config.routes || []
       }
     ]
   };
@@ -58,7 +88,7 @@ function loadConfig(customPath) {
   const file = ensureConfig(customPath);
   const raw = fs.readFileSync(file, 'utf8');
   try {
-    return { config: JSON.parse(raw), file };
+    return { config: normalizeConfig(JSON.parse(raw)), file };
   } catch (err) {
     throw new Error(`Failed to parse ${file}: ${err.message}`);
   }
@@ -70,4 +100,4 @@ function saveConfig(config, customPath) {
   return file;
 }
 
-module.exports = { defaultConfig, configPath, ensureConfig, loadConfig, saveConfig, DEFAULT_CONFIG_NAME };
+module.exports = { defaultConfig, normalizeConfig, configPath, ensureConfig, loadConfig, saveConfig, DEFAULT_CONFIG_NAME };

package/lib/pm2.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+
+function isInstalled() {
+  try {
+    execSync('pm2 -v', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensureInstalled() {
+  if (isInstalled()) return true;
+  console.log('[pm2] pm2 not found — installing globally via npm...');
+  try {
+    execSync('npm install -g pm2', { stdio: 'inherit' });
+    return isInstalled();
+  } catch (err) {
+    console.error('[pm2] Automatic install failed:', err.message);
+    console.error('[pm2] Install it manually with: npm install -g pm2');
+    return false;
+  }
+}
+
+function listApps() {
+  try {
+    const out = execSync('pm2 jlist', { encoding: 'utf8' });
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+
+function isRunning(name) {
+  return listApps().some(p => p.name === name && p.pm2_env && p.pm2_env.status === 'online');
+}
+
+// Starts (or restarts, if already registered) an app under pm2.
+// { name, cmd, cwd } — cmd can be "npm start", "node server.js", etc.
+function startApp({ name, cmd, cwd }) {
+  const exists = listApps().some(p => p.name === name);
+  if (exists) {
+    console.log(`[pm2] "${name}" already registered — restarting it.`);
+    const res = spawnSync('pm2', ['restart', name], { stdio: 'inherit' });
+    return res.status === 0;
+  }
+
+  console.log(`[pm2] Starting "${name}" (${cmd}) in ${cwd || process.cwd()} ...`);
+  // Split "npm start" style commands into interpreter + args so pm2 can
+  // manage them directly rather than as a raw shell string.
+  const parts = cmd.trim().split(/\s+/);
+  const bin = parts[0];
+  const args = parts.slice(1);
+
+  const pm2Args = ['start', bin, '--name', name];
+  if (cwd) pm2Args.push('--cwd', cwd);
+  if (args.length) pm2Args.push('--', ...args);
+
+  const res = spawnSync('pm2', pm2Args, { stdio: 'inherit' });
+  return res.status === 0;
+}
+
+function stopApp(name) {
+  spawnSync('pm2', ['stop', name], { stdio: 'inherit' });
+}
+
+function deleteApp(name) {
+  spawnSync('pm2', ['delete', name], { stdio: 'inherit' });
+}
+
+function logs(name) {
+  spawnSync('pm2', ['logs', name], { stdio: 'inherit' });
+}
+
+// Persists the current pm2 process list so it comes back after a reboot,
+// PROVIDED "pm2 startup" has also been run once (that step needs sudo and
+// is printed to the user rather than run automatically).
+function save() {
+  spawnSync('pm2', ['save'], { stdio: 'inherit' });
+}
+
+function printStartupInstructions() {
+  console.log('\n[pm2] To make your app(s) survive a machine reboot, run this once:');
+  console.log('  pm2 startup');
+  console.log('  (then copy/run the sudo command it prints)');
+  console.log('  pm2 save\n');
+}
+
+module.exports = {
+  isInstalled,
+  ensureInstalled,
+  listApps,
+  isRunning,
+  startApp,
+  stopApp,
+  deleteApp,
+  logs,
+  save,
+  printStartupInstructions
+};