halo-agent 1.1.0

package/index.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * HALO Local Agent
+ *
+ * Usage:
+ *   npx halo-agent init    — first-time setup (saves config to ~/.halo-agent/config.json)
+ *   npx halo-agent start   — start polling for queued jobs
+ *
+ * The agent connects to your real Chrome browser via CDP (port 9222).
+ * It uses your real session — your cookies, IP, fingerprint.
+ * No headless browser. No bot detection.
+ */
+
+const { loadConfig, saveConfig } = require('./config');
+const { connectToChrome } = require('./browser');
+const { startPolling } = require('./poller');
+const { startLocalServer } = require('./localServer');
+
+const [,, command, ...cmdArgs] = process.argv;
+
+async function main() {
+  if (command === 'init') {
+    await runInit();
+  } else if (command === 'pair') {
+    await runPair(cmdArgs[0]);
+  } else if (command === 'start' || !command) {
+    await runStart();
+  } else if (command === 'token') {
+    await runUpdateToken(cmdArgs[0]);
+  } else if (command === 'install-autostart') {
+    await runInstallAutostart();
+  } else if (command === 'uninstall-autostart') {
+    await runUninstallAutostart();
+  } else {
+    console.log('Usage:');
+    console.log('  halo-agent pair <code>          — one-click pair with the dashboard');
+    console.log('  halo-agent start                — start the agent');
+    console.log('  halo-agent install-autostart    — auto-start at login');
+    console.log('  halo-agent uninstall-autostart  — remove login auto-start');
+    console.log('  halo-agent init                 — first-time setup (legacy: token paste)');
+    console.log('  halo-agent token <value>        — update auth token');
+    process.exit(1);
+  }
+}
+
+async function runUpdateToken(newToken) {
+  const { loadConfig, saveConfig } = require('./config');
+  const token = newToken || (() => {
+    // Read from stdin if not passed as arg
+    const readline = require('readline');
+    return new Promise(r => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question('Paste new token: ', ans => { rl.close(); r(ans.trim()); });
+    });
+  })();
+  const resolved = typeof token === 'string' ? token : await token;
+  const config = loadConfig() || {};
+  config.token = resolved.trim();
+  saveConfig(config);
+  console.log('Token updated.');
+}
+
+// One-click pairing. The user generates a 6-char code in the dashboard
+// (Profile > Connect agent), then runs `halo-agent pair <code>`. We exchange
+// it for a long-lived session token and save it. Far better UX than asking
+// the user to copy-paste an API token.
+async function runPair(code) {
+  if (!code) {
+    console.error('Usage: halo-agent pair <code>');
+    console.error('Get a code from the HALO dashboard: Profile -> Connect agent.');
+    process.exit(1);
+  }
+  const trimmed = String(code).trim().toUpperCase();
+
+  // Default API URL — overridable via env for self-hosted Workers.
+  const apiUrl = process.env.HALO_API_URL || 'https://halo-apply-os.amoghi2tb.workers.dev';
+
+  console.log(`\nPairing with ${apiUrl}...`);
+  let res;
+  try {
+    res = await fetch(`${apiUrl}/agent-pair/claim`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ code: trimmed }),
+    });
+  } catch (e) {
+    console.error('Network error reaching HALO:', e.message);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    let msg = `HTTP ${res.status}`;
+    try { const j = await res.json(); msg = j.error || msg; } catch {}
+    console.error(`Pair failed: ${msg}`);
+    console.error('Codes expire 5 minutes after they are generated — get a fresh one if needed.');
+    process.exit(1);
+  }
+  const data = await res.json();
+  if (!data.token) { console.error('Pair response missing token.'); process.exit(1); }
+
+  const { loadConfig, saveConfig } = require('./config');
+  const existing = loadConfig() || {};
+  const config = {
+    ...existing,
+    apiUrl: data.api_url || apiUrl,
+    token: data.token,
+    userId: data.user_id,
+  };
+  saveConfig(config);
+
+  console.log('\nPaired. Token saved to ~/.halo-agent/config.json');
+  console.log('Run `halo-agent start` to connect the agent.\n');
+}
+
+// Auto-start at login. The user picked "always on" — once installed, the
+// agent reconnects automatically at boot and stays connected. Platform-
+// specific service hooks:
+//   macOS    -> LaunchAgent plist in ~/Library/LaunchAgents
+//   Windows  -> .vbs in the user's Startup folder (runs node detached)
+//   Linux    -> systemd --user unit
+//
+// On install we also write a shell wrapper that resolves the node + agent
+// paths at install time so the service doesn't depend on the user's shell
+// PATH at boot. The wrapper logs to ~/.halo-agent/agent.log.
+async function runInstallAutostart() {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const { CONFIG_DIR } = require('./config');
+
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+
+  // Resolve the agent's entry path at install time so the service
+  // doesn't break if `npx` cache moves.
+  const nodePath = process.execPath;       // e.g. /usr/local/bin/node
+  const agentPath = path.resolve(__filename);
+  const logPath = path.join(CONFIG_DIR, 'agent.log');
+
+  if (process.platform === 'darwin') {
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    const plistPath = path.join(plistDir, 'com.halo.agent.plist');
+    if (!fs.existsSync(plistDir)) fs.mkdirSync(plistDir, { 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>com.halo.agent</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${agentPath}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plist);
+    // Load it so it starts immediately (and auto-loads on subsequent logins).
+    try {
+      const { spawnSync } = require('child_process');
+      spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+      spawnSync('launchctl', ['load', plistPath], { stdio: 'ignore' });
+    } catch { /* user can `launchctl load` manually */ }
+    console.log(`\nInstalled login auto-start (macOS LaunchAgent).`);
+    console.log(`  plist: ${plistPath}`);
+    console.log(`  logs:  ${logPath}`);
+    console.log(`The agent will start automatically at login. It's running now.`);
+    return;
+  }
+
+  if (process.platform === 'win32') {
+    // A .vbs in the Startup folder runs the node process hidden (no
+    // terminal flash). Simpler than schtasks; works for per-user always-on.
+    const startupDir = path.join(process.env.APPDATA || os.homedir(), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+    if (!fs.existsSync(startupDir)) fs.mkdirSync(startupDir, { recursive: true });
+    const vbsPath = path.join(startupDir, 'halo-agent.vbs');
+    const vbs = `Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${nodePath.replace(/"/g, '""')}"" ""${agentPath.replace(/"/g, '""')}"" start", 0, False
+Set WshShell = Nothing`;
+    fs.writeFileSync(vbsPath, vbs);
+    console.log(`\nInstalled login auto-start (Windows Startup folder).`);
+    console.log(`  vbs: ${vbsPath}`);
+    console.log(`  logs: ${logPath} (agent appends its own output)`);
+    console.log(`The agent will start at your next login. Run \`halo-agent start\` now to begin this session.`);
+    return;
+  }
+
+  // Linux: systemd --user unit. Requires systemd (most modern distros).
+  const unitDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  if (!fs.existsSync(unitDir)) fs.mkdirSync(unitDir, { recursive: true });
+  const unitPath = path.join(unitDir, 'halo-agent.service');
+  const unit = `[Unit]
+Description=HALO local apply agent
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${agentPath} start
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+
+[Install]
+WantedBy=default.target
+`;
+  fs.writeFileSync(unitPath, unit);
+  try {
+    const { spawnSync } = require('child_process');
+    spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    spawnSync('systemctl', ['--user', 'enable', '--now', 'halo-agent.service'], { stdio: 'ignore' });
+    // Linger so the unit survives logout — best effort.
+    spawnSync('loginctl', ['enable-linger', os.userInfo().username], { stdio: 'ignore' });
+  } catch { /* user can enable manually */ }
+  console.log(`\nInstalled login auto-start (systemd --user).`);
+  console.log(`  unit: ${unitPath}`);
+  console.log(`  logs: ${logPath}`);
+  console.log(`The agent should be running now: systemctl --user status halo-agent`);
+}
+
+async function runUninstallAutostart() {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+
+  if (process.platform === 'darwin') {
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.halo.agent.plist');
+    try {
+      const { spawnSync } = require('child_process');
+      spawnSync('launchctl', ['unload', plistPath], { stdio: 'ignore' });
+    } catch {}
+    if (fs.existsSync(plistPath)) fs.unlinkSync(plistPath);
+    console.log('Removed macOS LaunchAgent.');
+    return;
+  }
+  if (process.platform === 'win32') {
+    const vbsPath = path.join(process.env.APPDATA || os.homedir(), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'halo-agent.vbs');
+    if (fs.existsSync(vbsPath)) fs.unlinkSync(vbsPath);
+    console.log('Removed Windows Startup entry.');
+    return;
+  }
+  try {
+    const { spawnSync } = require('child_process');
+    spawnSync('systemctl', ['--user', 'disable', '--now', 'halo-agent.service'], { stdio: 'ignore' });
+  } catch {}
+  const unitPath = path.join(os.homedir(), '.config', 'systemd', 'user', 'halo-agent.service');
+  if (fs.existsSync(unitPath)) fs.unlinkSync(unitPath);
+  console.log('Removed systemd --user unit.');
+}
+
+async function runInit() {
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(r => rl.question(q, r));
+
+  console.log('\nHALO Agent Setup\n');
+  console.log('You need your HALO API token and (optionally) a CapSolver API key.\n');
+
+  const apiUrl = await ask('HALO API URL [https://halo-apply-os.workers.dev]: ');
+  const token = await ask('HALO API token (from Settings in dashboard): ');
+  const captchaKey = await ask('CapSolver API key (optional, press Enter to skip): ');
+  const anthropicKey = await ask('Anthropic API key for vision fallback (optional): ');
+  const autoSubmit = (await ask('Auto-submit without confirmation? [y/N]: ')).toLowerCase() === 'y';
+
+  console.log('\nCloudflare Access (if your Worker is behind CF Access):');
+  console.log('Get these from: Cloudflare Zero Trust > Access > Service Auth > Create Service Token');
+  const cfClientId = await ask('CF Access Client ID (optional, press Enter to skip): ');
+  const cfClientSecret = await ask('CF Access Client Secret (optional, press Enter to skip): ');
+
+  rl.close();
+
+  const config = {
+    apiUrl: apiUrl.trim() || 'https://halo-apply-os.workers.dev',
+    token: token.trim(),
+    captchaApiKey: captchaKey.trim() || null,
+    anthropicApiKey: anthropicKey.trim() || null,
+    autoSubmit,
+    typingSpeed: 'normal',
+    useVisionFallback: true,
+    cfAccessClientId: cfClientId.trim() || null,
+    cfAccessClientSecret: cfClientSecret.trim() || null,
+  };
+
+  saveConfig(config);
+  console.log('\nConfig saved to ~/.halo-agent/config.json');
+  console.log('Run "halo-agent start" to begin.\n');
+}
+
+async function runStart() {
+  const config = loadConfig();
+  if (!config || !config.token) {
+    console.error('No config found. Run "halo-agent init" first.');
+    process.exit(1);
+  }
+
+  console.log('\nHALO Agent starting...');
+  console.log('Connecting to your Chrome browser...\n');
+
+  // Pre-check: if Chrome is running WITHOUT debug port, warn immediately
+  const { isChromeDebuggable } = require('./browser');
+  const alreadyDebuggable = await isChromeDebuggable();
+  if (!alreadyDebuggable) {
+    const { execSync } = require('child_process');
+    let chromeRunning = false;
+    let chromeHasDebugFlag = false;
+    try {
+      execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
+      chromeRunning = true;
+    } catch {}
+    if (chromeRunning) {
+      try {
+        const psOut = execSync('ps aux', { encoding: 'utf8' });
+        chromeHasDebugFlag = psOut.includes('--remote-debugging-port=9222');
+      } catch {}
+    }
+    if (chromeRunning && !chromeHasDebugFlag) {
+      console.error('Chrome is already running WITHOUT remote debugging enabled.\n');
+      console.error('You need to fully quit Chrome first, then relaunch it with the debug flag.\n');
+      console.error('Run these commands:\n');
+      console.error('  pkill -a -i "Google Chrome"');
+      console.error('  sleep 2');
+      console.error('  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --profile-directory=Default &');
+      console.error('  sleep 4');
+      console.error('  node index.js start\n');
+      process.exit(1);
+    }
+  }
+
+  let chromeConn;
+  try {
+    chromeConn = await connectToChrome();
+    console.log('\nConnected to Chrome. Polling for queued jobs...');
+    console.log('Go to your HALO dashboard and click "Auto-Apply" on any job.\n');
+  } catch (err) {
+    console.error('\nCould not connect to Chrome:', err.message);
+    process.exit(1);
+  }
+
+  // Start the local HTTP server so the HALO dashboard can trigger Manus automation
+  startLocalServer();
+
+  // Graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\nShutting down...');
+    try { await chromeConn.browser.close(); } catch {}
+    process.exit(0);
+  });
+
+  await startPolling(chromeConn, config);
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

package/localServer.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/**
+ * localServer.js
+ *
+ * Lightweight HTTP server that runs on localhost:7788.
+ *
+ * Endpoints:
+ *   GET  /health                     — liveness check
+ *   POST /manus-automate             — dispatch a prompt to Manus
+ *   POST /fill                       — extension-triggered fill (Architecture 4 handoff)
+ *   GET  /fill-status/:fillId        — poll fill progress from extension
+ *   POST /fill-confirm/:fillId       — user confirmed submit from extension overlay
+ */
+
+const http = require('http');
+const { connectChrome, dispatchManusTask, pollManusTaskStatus } = require('./manusAutomate');
+const { runExtensionFill } = require('./orchestrator');
+const { loadConfig, cfAccessHeaders } = require('./config');
+
+const PORT = 7788;
+let chromeConn = null; // reused across requests
+
+// In-memory fill session map: fillId -> { state, message, fieldsFilled, reviewScreenshot, error, confirmResolve }
+const fillSessions = new Map();
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', () => {
+      try { resolve(JSON.parse(body || '{}')); }
+      catch (e) { reject(new Error('Invalid JSON: ' + e.message)); }
+    });
+    req.on('error', reject);
+  });
+}
+
+function send(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+  });
+  res.end(body);
+}
+
+async function ensureChromeConn() {
+  if (chromeConn) {
+    // Verify connection is still alive
+    try {
+      chromeConn.browser.contexts(); // will throw if disconnected
+      return chromeConn;
+    } catch {
+      chromeConn = null;
+    }
+  }
+  chromeConn = await connectChrome();
+  return chromeConn;
+}
+
+async function handleRequest(req, res) {
+  const url = new URL(req.url, `http://localhost:${PORT}`);
+
+  // CORS preflight
+  if (req.method === 'OPTIONS') {
+    send(res, 204, {});
+    return;
+  }
+
+  // GET /health
+  if (req.method === 'GET' && url.pathname === '/health') {
+    let chromeOk = false;
+    try {
+      await ensureChromeConn();
+      chromeOk = true;
+    } catch {}
+    send(res, 200, { ok: true, chrome: chromeOk, port: PORT });
+    return;
+  }
+
+  // POST /manus-automate
+  if (req.method === 'POST' && url.pathname === '/manus-automate') {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (e) {
+      send(res, 400, { error: e.message });
+      return;
+    }
+
+    const { prompt, jobId, queueId, apiUrl, token } = body;
+    if (!prompt) { send(res, 400, { error: 'prompt is required' }); return; }
+
+    // Respond immediately so the dashboard doesn't wait (automation runs async)
+    send(res, 202, { ok: true, message: 'Manus automation started', jobId, queueId });
+
+    // Run automation in the background
+    setImmediate(async () => {
+      try {
+        console.log(`[local-server] Starting Manus automation for job ${jobId}...`);
+
+        const conn = await ensureChromeConn();
+        const result = await dispatchManusTask(prompt, conn);
+
+        const cfg = loadConfig() || {};
+        const cfHeaders = cfAccessHeaders(cfg);
+
+        if ('error' in result) {
+          console.error('[local-server] dispatchManusTask failed:', result.error);
+          if (queueId && apiUrl && token) {
+            await fetch(`${apiUrl}/apply-queue/${queueId}`, {
+              method: 'PATCH',
+              headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', ...cfHeaders },
+              body: JSON.stringify({ status: 'NEEDS_ATTENTION', needs_attention_reason: result.error }),
+            }).catch(() => {});
+          }
+          return;
+        }
+
+        console.log(`[local-server] Task dispatched: taskId=${result.taskId}, url=${result.taskUrl}`);
+
+        // Report task URL back to HALO (store on queue item as submission_id / note)
+        if (queueId && apiUrl && token) {
+          await fetch(`${apiUrl}/apply-queue/${queueId}`, {
+            method: 'PATCH',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', ...cfHeaders },
+            body: JSON.stringify({
+              status: 'IN_PROGRESS',
+              submission_id: result.taskId || null,
+              progress_note: result.taskUrl || null,
+            }),
+          }).catch(() => {});
+        }
+
+        // Poll Manus for task completion and report back
+        if (result.taskId && apiUrl && token) {
+          await pollManusTaskStatus(result.taskId, queueId, { apiUrl, token, cfHeaders });
+        } else {
+          console.warn('[local-server] No taskId extracted — cannot poll for completion');
+        }
+      } catch (e) {
+        console.error('[local-server] Automation error:', e.message);
+        const cfg = loadConfig() || {};
+        if (queueId && apiUrl && token) {
+          await fetch(`${apiUrl}/apply-queue/${queueId}`, {
+            method: 'PATCH',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', ...cfAccessHeaders(cfg) },
+            body: JSON.stringify({ status: 'NEEDS_ATTENTION', needs_attention_reason: e.message }),
+          }).catch(() => {});
+        }
+      }
+    });
+
+    return;
+  }
+
+  // POST /fill — extension hands off a job page for agent filling
+  if (req.method === 'POST' && url.pathname === '/fill') {
+    let body;
+    try { body = await readBody(req); } catch (e) { send(res, 400, { error: e.message }); return; }
+
+    const { apply_url, job_id, ats_type, packet, config: extConfig } = body;
+    if (!apply_url) { send(res, 400, { error: 'apply_url is required' }); return; }
+
+    const fillId = 'fill_' + Date.now() + '_' + Math.random().toString(36).slice(2, 8);
+    fillSessions.set(fillId, {
+      state: 'ANALYZING',
+      message: 'Starting agent fill...',
+      fieldsFilled: 0,
+      reviewScreenshot: null,
+      error: null,
+      confirmResolve: null,
+    });
+
+    // Respond immediately — fill runs async
+    send(res, 202, { ok: true, fill_id: fillId });
+
+    // Run fill in background
+    setImmediate(async () => {
+      const session = fillSessions.get(fillId);
+      const reportFillStatus = (state, extra = {}) => {
+        Object.assign(session, { state, ...extra });
+      };
+
+      try {
+        const conn = await ensureChromeConn();
+        await runExtensionFill({
+          fillId,
+          apply_url,
+          job_id,
+          ats_type,
+          packet,
+          extConfig,
+          chromeConn: conn,
+          reportFillStatus,
+          waitForConfirm: () => new Promise(resolve => { session.confirmResolve = resolve; }),
+        });
+      } catch (e) {
+        console.error(`[local-server] Fill ${fillId} error:`, e.message);
+        const s = fillSessions.get(fillId);
+        if (s) { s.state = 'FAILED'; s.error = e.message; }
+      }
+    });
+
+    return;
+  }
+
+  // GET /fill-status/:fillId — extension polls this every 2s
+  const fillStatusMatch = url.pathname.match(/^\/fill-status\/(.+)$/);
+  if (req.method === 'GET' && fillStatusMatch) {
+    const fillId = fillStatusMatch[1];
+    const session = fillSessions.get(fillId);
+    if (!session) { send(res, 404, { error: 'Fill session not found' }); return; }
+    send(res, 200, {
+      state: session.state,
+      message: session.message,
+      fields_filled: session.fieldsFilled,
+      review_screenshot: session.reviewScreenshot || null,
+      error: session.error || null,
+    });
+    return;
+  }
+
+  // POST /fill-confirm/:fillId — user confirmed submit from extension overlay
+  const fillConfirmMatch = url.pathname.match(/^\/fill-confirm\/(.+)$/);
+  if (req.method === 'POST' && fillConfirmMatch) {
+    const fillId = fillConfirmMatch[1];
+    const session = fillSessions.get(fillId);
+    if (!session) { send(res, 404, { error: 'Fill session not found' }); return; }
+    if (session.confirmResolve) {
+      session.confirmResolve();
+      session.confirmResolve = null;
+    }
+    send(res, 200, { ok: true });
+    return;
+  }
+
+  send(res, 404, { error: 'Not found' });
+}
+
+function startLocalServer() {
+  const server = http.createServer(async (req, res) => {
+    try {
+      await handleRequest(req, res);
+    } catch (e) {
+      console.error('[local-server] Unhandled error:', e.message);
+      try { send(res, 500, { error: e.message }); } catch {}
+    }
+  });
+
+  server.listen(PORT, '127.0.0.1', () => {
+    console.log(`[local-server] HALO agent server running on http://127.0.0.1:${PORT}`);
+    console.log(`[local-server] Dashboard will send Auto-Apply requests here.`);
+  });
+
+  server.on('error', (e) => {
+    if (e.code === 'EADDRINUSE') {
+      console.warn(`[local-server] Port ${PORT} already in use — another agent instance may be running.`);
+    } else {
+      console.error('[local-server] Server error:', e.message);
+    }
+  });
+
+  return server;
+}
+
+module.exports = { startLocalServer };