codebase-onboarder 0.1.0 → 0.2.0

package/README.md

@@ -3,7 +3,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen.svg)](https://nodejs.org/)
 [![Zero Dependencies](https://img.shields.io/badge/runtime%20dependencies-0-success.svg)](package.json)
-[![Tests](https://img.shields.io/badge/tests-546%20passing-brightgreen.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-551%20passing-brightgreen.svg)](tests/)
 
 > **Drop a path. Get a map.**  
 > A lightweight, zero-dependency codebase visualizer and architectural map generator that runs entirely on your local machine.
@@ -205,16 +205,24 @@ Onboarder has two modes, one config file, and three ways to edit it — the CLI
 - **Self-hosted** — reachable on your network or domain; every API call requires a Bearer access key. Rotate it from the drawer or with `onboarder config key rotate`; the old key dies on the next request, no restart needed.
 
 ```bash
-onboarder setup                          # interactive wizard (OpenClaw-style)
+onboarder setup                          # interactive wizard
 onboarder setup --mode self-hosted \
   --domain map.example.com --non-interactive
 onboarder config show                    # current settings (key masked)
-onboarder config set domain map.example.com
+onboarder config set host 0.0.0.0        # direct VPS/LAN access (domain optional)
+onboarder config set port 4311           # move away from a busy port
 onboarder config key rotate              # mint a new access key
+onboarder status                         # running PID, stopped, or unmanaged port owner
+onboarder stop                           # stop a PID-file-managed instance
+onboarder restart                        # graceful stop, then start
 onboarder tunnel cloudflare              # expose via a Cloudflare quick tunnel
-onboarder doctor                         # config, port, and tunnel checks
+onboarder doctor                         # config, port, reachability, and tunnel checks
 ```
 
+Direct self-hosting does not require DNS: `--host 0.0.0.0` accepts visitors at `http://<server-ip>:<port>`. Put a reverse proxy and TLS in front of it for production. Binding to `127.0.0.1` is still the safer default and is appropriate behind Cloudflare or Tailscale.
+
+If startup reports `EADDRINUSE`, run `onboarder status` first. If it identifies an Onboarder PID, use `onboarder stop` or `onboarder restart`; otherwise inspect the unrelated listener with `ss -ltnp` or `lsof -i :4310`, or choose another port. The error names these recovery commands instead of printing only the raw Node error.
+
 Cloudflare quick tunnels and Tailscale are supported as reachability layers — the server keeps its loopback bind and the tunnel dials `127.0.0.1`. `ONBOARDER_CONFIG=/path/config.json` overrides the config location (handy for tests and containers).
 
 ---
@@ -228,6 +236,7 @@ codebase-onboarder/
 ├── server/          # Zero-dependency Node.js HTTP server
 │   ├── index.js     # createServer / startServer / startup banner
 │   ├── config.js    # Settings schema, normalization, atomic 0600 writes
+│   ├── pidfile.js   # PID ownership for status / stop / restart
 │   ├── router.js    # Route table, live per-request settings, Bearer gate
 │   ├── apiSettings.js# GET/PUT /api/settings, key rotation
 │   ├── tunnel.js    # Cloudflare & Tailscale status/commands
@@ -243,7 +252,7 @@ codebase-onboarder/
 │   ├── js/          # Vanilla ES modules (State, Inspector, Views, Settings)
 │   ├── vendor/      # Vendored Mermaid & Monaco Editor (Offline)
 │   └── index.html   # Main application interface
-└── tests/           # Comprehensive node:test suite (546 unit tests)
+└── tests/           # Comprehensive node:test suite (551 unit tests)
 ```
 
 ---
@@ -253,7 +262,7 @@ codebase-onboarder/
 Onboarder includes a comprehensive automated test suite built with Node's native test runner:
 
 ```bash
-# Run all 546 tests
+# Run all 551 tests
 npm test
 ```
 

package/cli/commands.js

@@ -15,6 +15,7 @@ import {
   publicSettings, serverUrls, maskAccessKey,
 } from '../server/config.js';
 import { startServer } from '../server/index.js';
+import { pidIsAlive, readPidFile, removePidFile } from '../server/pidfile.js';
 import { tunnelStatus, cloudflareCommand, tailscaleCommand, installHint, findOnPath } from '../server/tunnel.js';
 import { bold, cyan, dim, ok, warn, bad, kv, tick, cross, dash, welcomeBanner } from './ui.js';
 import { buildSteps, pendingSteps, defaultOf, applyFlags, answersToSettings, summaryLines } from './wizard.js';
@@ -153,11 +154,113 @@ export async function runStart({ flags = {}, out = console.log, err = console.er
     }
     out(dim(`  No config at ${file} — starting with defaults (local mode).`));
   }
-  const { server, host, port } = await startServer({ configFile: file, log: out });
-  if (flags.json) out(JSON.stringify({ host, port, url: `http://127.0.0.1:${port}/` }));
+  const recorded = readPidFile(file);
+  if (recorded && pidIsAlive(recorded)) {
+    err(`  Onboarder is already running (PID ${recorded}).`);
+    err(dim('    Use `onboarder status`, `onboarder stop`, or `onboarder restart`.'));
+    return 1;
+  }
+  if (recorded) removePidFile(file, recorded);
+
+  const started = await startServer({ configFile: file, log: out });
+  if (flags.json) out(JSON.stringify({ host: started.host, port: started.port, url: serverUrls(started.settings).local }));
   // The listening server holds the event loop; resolve so callers/tests know
   // we are up, but leave the process running.
-  return { server, host, port, code: 0 };
+  return { ...started, code: 0 };
+}
+
+// ------------------------------------------------------------- lifecycle ---
+
+export async function runStatus({ flags = {}, out = console.log } = {}) {
+  const file = flags.config || configPath();
+  const pid = readPidFile(file);
+  let running = pid && pidIsAlive(pid);
+  let settings = null;
+  try { settings = await readSettings(file); } catch { /* defaults are still meaningful */ }
+  const portBusy = settings ? !(await portIsFree(settings.host, settings.port)) : false;
+  if (pid && !running) removePidFile(file, pid);
+  const result = {
+    running: Boolean(running || portBusy),
+    pid: running ? pid : null,
+    port: settings ? `${settings.host}:${settings.port}` : null,
+    portBusy,
+    managed: Boolean(running),
+    configFile: file,
+  };
+  if (flags.json) {
+    out(JSON.stringify(result, null, 2));
+  } else {
+    out('');
+    out(bold('  Onboarder status'));
+    if (running) out(`${tick}Running    PID ${pid}`);
+    else if (portBusy) out(`${warn('!')}Port busy  ${result.port} (no Onboarder PID record)`);
+    else out(`${dash}Stopped`);
+    out(kv('Config', file));
+    if (result.portBusy && !running) out(dim('    Inspect it with `ss -ltnp` or `lsof -i :' + settings.port + '` before stopping another process.'));
+  }
+  return 0;
+}
+
+function waitForExit(pid, timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const poll = () => {
+      if (!pidIsAlive(pid)) return resolve(true);
+      if (Date.now() - started >= timeoutMs) return resolve(false);
+      setTimeout(poll, 100);
+    };
+    poll();
+  });
+}
+
+export async function runStop({ flags = {}, out = console.log, err = console.error } = {}) {
+  const file = flags.config || configPath();
+  const pid = readPidFile(file);
+  if (!pid) {
+    const settings = await readSettings(file);
+    const portBusy = !(await portIsFree(settings.host, settings.port));
+    if (flags.json) out(JSON.stringify({ stopped: false, reason: portBusy ? 'unmanaged busy port' : 'not running', port: `${settings.host}:${settings.port}` }, null, 2));
+    else if (portBusy) {
+      out(`${warn('!')}Port busy  ${settings.host}:${settings.port} — no Onboarder process record.`);
+      out(dim('    Inspect it with `ss -ltnp` or `lsof -i :' + settings.port + '`; `onboarder stop` will not kill an unmanaged process.'));
+    } else {
+      out(`${dash}Not running.`);
+    }
+    return portBusy ? 1 : 0;
+  }
+  if (!pidIsAlive(pid)) {
+    removePidFile(file, pid);
+    if (flags.json) out(JSON.stringify({ stopped: true, pid, stale: true }, null, 2));
+    else out(tick + `Removed stale process record for PID ${pid}.`);
+    return 0;
+  }
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (error) {
+    if (error?.code !== 'ESRCH') throw error;
+  }
+  const stopped = await waitForExit(pid);
+  if (!stopped && pidIsAlive(pid)) {
+    err(`  PID ${pid} did not stop after SIGTERM.`);
+    err(dim('    Check it with `ps -p ' + pid + ' -f`, then stop it only if it really is Onboarder.'));
+    return 1;
+  }
+  removePidFile(file, pid);
+  if (flags.json) out(JSON.stringify({ stopped: true, pid }, null, 2));
+  else out(tick + `Stopped Onboarder (PID ${pid}).`);
+  return 0;
+}
+
+export async function runRestart(options = {}) {
+  const file = options.flags?.config || configPath();
+  const pid = readPidFile(file);
+  if (pid && pidIsAlive(pid)) {
+    const stopped = await runStop(options);
+    if (stopped !== 0) return stopped;
+  } else if (pid) {
+    removePidFile(file, pid);
+  }
+  return runStart(options);
 }
 
 // --------------------------------------------------------------- config ---
@@ -341,8 +444,8 @@ export async function runDoctor({ flags = {}, out = console.log } = {}) {
       });
       const loopback = ['127.0.0.1', 'localhost', '::1', '[::1]'].includes(settings.host);
       checks.push({
-        id: 'domain', ok: loopback || Boolean(settings.domain), required: !loopback,
-        detail: settings.domain || (loopback ? '(none — a tunnel provides the name)' : 'MISSING — a LAN bind needs a domain'),
+        id: 'domain', ok: true, required: false,
+        detail: settings.domain || (loopback ? '(none — a tunnel or local reverse proxy provides the name)' : '(none — visitors can connect by server IP)'),
       });
     }
   }
@@ -433,4 +536,3 @@ export async function runTunnel(kind, { flags = {}, out = console.log, err = con
   }
   throw new Error('Usage: onboarder tunnel <cloudflare|tailscale>');
 }
-

package/cli/main.js

@@ -7,7 +7,10 @@
 import fs from 'node:fs';
 import { parseArgs } from 'node:util';
 
-import { runSetup, runStart, runConfig, runConfigKey, runConfigReset, runDoctor, runTunnel } from './commands.js';
+import {
+  runSetup, runStart, runStatus, runStop, runRestart,
+  runConfig, runConfigKey, runConfigReset, runDoctor, runTunnel,
+} from './commands.js';
 
 const PACKAGE = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 
@@ -18,7 +21,10 @@ const HELP = `
     onboarder                     Start the server (runs setup first if needed)
     onboarder setup | onboard     Configure interactively (the wizard)
     onboarder start               Start the server
-    onboarder config <…>          show | get <key> | set <key> <value> | path | reset | key <rotate|show|set>
+    onboarder status              Show whether the server is running
+    onboarder stop                Stop the running server
+    onboarder restart             Stop and start again
+    onboarder config [<…>]         show | get <key> | set <key> <value> | path | reset | key <rotate|show|set>
     onboarder tunnel <name>       cloudflare | tailscale
     onboarder doctor              Check the machine and the config
 
@@ -37,6 +43,10 @@ const HELP = `
     --no-color          Plain output (NO_COLOR works too)
     -h, --help          This text      -v, --version      Print the version
 
+  Also accepted
+    help | --help       onboarder help | onboarder --help
+    config | config show
+
   Examples
     onboarder setup
     onboarder setup --non-interactive --mode local --port 4310
@@ -97,9 +107,18 @@ export async function main(argv = process.argv.slice(2)) {
   const [cmd, sub, ...rest] = positionals;
   try {
     switch (cmd) {
+      case 'help':
+        console.log(HELP);
+        return 0;
       case undefined:
       case 'start':
         return codeOf(await runStart({ flags }));
+      case 'status':
+        return codeOf(await runStatus({ flags }));
+      case 'stop':
+        return codeOf(await runStop({ flags }));
+      case 'restart':
+        return codeOf(await runRestart({ flags }));
       case 'setup':
       case 'onboard':
       case 'init':
@@ -107,7 +126,7 @@ export async function main(argv = process.argv.slice(2)) {
       case 'config':
         if (sub === 'key') return codeOf(await runConfigKey(rest[0], rest.slice(1), { flags }));
         if (sub === 'reset') return codeOf(await runConfigReset({ flags }));
-        return codeOf(await runConfig(sub, rest, { flags }));
+        return codeOf(await runConfig(sub || 'show', rest, { flags }));
       case 'tunnel':
         return codeOf(await runTunnel(sub, { flags }));
       case 'doctor':

package/cli/prompt.js

@@ -32,6 +32,11 @@ export async function runSteps(steps, answers = {}, io = {}) {
   try {
     let lastSection = null;
     for (const step of steps) {
+      // `when` is evaluated here, one question at a time — never upfront.
+      // Conditions read answers collected earlier in the same run ("ask about
+      // the bind only when mode is self-hosted"), so filtering the list
+      // before the first question would prune branches the answers reopen.
+      if (step.when && !step.when(answers)) continue;
       if (step.section && step.section !== lastSection) {
         output.write(section(step.section) + '\n');
         lastSection = step.section;

package/cli/wizard.js

@@ -12,7 +12,7 @@
 
 import os from 'node:os';
 
-import { DEFAULT_SETTINGS, generateAccessKey, normalizeSettings } from '../server/config.js';
+import { DEFAULT_SETTINGS, generateAccessKey, isLoopbackHost, normalizeSettings } from '../server/config.js';
 
 // Provider presets for the AI account step. `none` is the honest default: the
 // app works fully offline, and the browser can still hold its own key.
@@ -113,8 +113,8 @@ export function buildSteps(current = DEFAULT_SETTINGS) {
     },
     {
       id: 'domain', section: 'Server', type: 'text',
-      question: 'Domain (optional behind a tunnel)',
-      hint: 'e.g. map.example.com — required for a direct LAN bind, optional when a tunnel provides the name',
+      question: 'Domain (optional; not needed when reached by IP or behind a tunnel)',
+      hint: 'e.g. map.example.com — use a hostname only when visitors will connect by domain',
       default: current.domain || '',
       validate: validDomain,
       when: (a) => a.mode === 'self-hosted',
@@ -190,6 +190,16 @@ export function pendingSteps(steps, answers = {}) {
   return steps.filter((s) => !(s.id in answers) && (!s.when || s.when(answers)));
 }
 
+// Steps the flags did not answer, in order — and nothing more. Unlike
+// `pendingSteps` this never looks at `when`: conditions read answers that
+// only exist mid-run ("ask about the bind once mode is self-hosted"), so
+// evaluating them before the first question prunes branches the typed answers
+// would reopen. The renderer (`prompt.js#runSteps`) evaluates `when` live,
+// one question at a time, which is the only moment it can be answered truly.
+export function unansweredSteps(steps, answers = {}) {
+  return steps.filter((s) => !(s.id in answers));
+}
+
 // Defaults may depend on earlier answers (`default` as a function).
 export function defaultOf(step, answers) {
   return typeof step.default === 'function' ? step.default(answers) : step.default;
@@ -311,6 +321,9 @@ export function summaryLines(settings, { revealKey = false } = {}) {
     lines.push(['Access key', revealKey
       ? settings.accessKey
       : (settings.accessKey ? settings.accessKey.slice(0, 6) + '… (hidden)' : '(none — the API will refuse every call)')]);
+    if (isLoopbackHost(settings.host)) {
+      lines.push(['Network', 'loopback only — use a tunnel or bind 0.0.0.0 for direct access']);
+    }
   }
   const who = [settings.account.name, settings.account.email].filter(Boolean).join(' · ');
   if (who) lines.push(['Profile', who]);
@@ -322,4 +335,3 @@ export function summaryLines(settings, { revealKey = false } = {}) {
   lines.push(['Auto-open', settings.autoOpen ? 'yes' : 'no']);
   return lines;
 }
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebase-onboarder",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Drop a path. Get a map. A zero-dependency codebase visualizer with a CLI onboarding wizard, a web UI, and an optional key-gated self-hosted mode.",
   "type": "module",
   "bin": {

package/public/js/api.js

@@ -261,4 +261,3 @@ export async function updateServerSettings(patch) {
 export function rotateServerAccessKey() {
   return postJSON('/api/settings/access-key', {});
 }
-

package/public/js/serverSettings.js

@@ -166,4 +166,3 @@ export function createServerDrawer(options = {}) {
     isOpen: () => !dom.serverDrawer.hidden,
   };
 }
-

package/server/config.js

@@ -91,9 +91,10 @@ export function normalizeSettings(value = {}) {
   if (settings.mode === 'local' && !isLoopbackHost(settings.host)) {
     throw new Error('Local mode only binds to 127.0.0.1, localhost, or ::1. Choose self-hosted mode for a network bind.');
   }
-  if (settings.mode === 'self-hosted' && !isLoopbackHost(settings.host) && !settings.domain) {
-    throw new Error('A self-hosted network bind needs a domain (or keep the server on loopback behind a tunnel).');
-  }
+  // Self-hosted needs no domain: a bare-IP bind (a VPS with no DNS name) is a
+  // legitimate layout. The rebinding guard still answers only to the
+  // configured domain or this machine's own interface addresses (see
+  // allowedHosts), and every API call needs the access key either way.
   return settings;
 }
 
@@ -154,11 +155,34 @@ export function publicSettings(value = DEFAULT_SETTINGS) {
 // safe because it can only widen Host acceptance in self-hosted mode, where
 // every API call already needs the access key — the guard's job there is
 // keeping drive-by traffic off the static files, not authentication.
+// A wildcard bind (0.0.0.0 / ::) has no name of its own, so the names it
+// honestly answers to are this machine's own interface addresses — a request
+// addressed to 10.0.0.2 or a public VPS IP really did arrive here. Read at
+// call time (the router asks per request), so a DHCP lease change does not
+// strand the guard on a stale address.
+function ownInterfaceHosts() {
+  const hosts = [];
+  for (const list of Object.values(os.networkInterfaces())) {
+    for (const addr of list || []) {
+      if (addr.internal) continue; // loopback is always allowed anyway
+      hosts.push(addr.address);
+    }
+  }
+  return hosts;
+}
+
 export function allowedHosts(value = DEFAULT_SETTINGS) {
   const settings = normalizeSettings(value);
   const hosts = new Set();
   if (settings.domain) hosts.add(settings.domain);
-  if (!isLoopbackHost(settings.host)) hosts.add(settings.host.toLowerCase());
+  if (!isLoopbackHost(settings.host)) {
+    // A wildcard bind is useful as a literal Host value to diagnostics, even
+    // though browsers normally address the machine by one of its real IPs.
+    hosts.add(settings.host.toLowerCase());
+    if (settings.host === '0.0.0.0' || settings.host === '::') {
+      for (const ip of ownInterfaceHosts()) hosts.add(ip);
+    }
+  }
   if (settings.tunnel.cloudflare) hosts.add('*.trycloudflare.com');
   if (settings.tunnel.tailscale) hosts.add('*.ts.net');
   return [...hosts];

package/server/index.js

@@ -21,8 +21,9 @@ import { createRouter } from './router.js';
 import { installExitCleanup } from './sessions.js';
 import { createLogger } from './logger.js';
 import { createMcpRunner } from './mcp/runner.js';
-import { configPath, readSettings, serverUrls } from './config.js';
+import { configPath, isLoopbackHost, readSettings, serverUrls } from './config.js';
 import { tunnelStatus } from './tunnel.js';
+import { pidIsAlive, readPidFile, removePidFile, writePidFile } from './pidfile.js';
 
 const logger = createLogger();
 
@@ -66,7 +67,9 @@ export function startupBanner(settings, { configFile } = {}) {
   const urls = serverUrls(settings);
   const lines = ['', '  Onboarder is up.'];
   lines.push(settings.mode === 'self-hosted'
-    ? '  Mode    self-hosted — the network can reach this; every API call needs the access key'
+    ? (isLoopbackHost(settings.host)
+      ? '  Mode    self-hosted — loopback bind; use a tunnel or change the host for direct network access'
+      : '  Mode    self-hosted — the network can reach this; every API call needs the access key')
     : '  Mode    local — only this machine can reach it');
   lines.push('  Local   ' + urls.local);
   if (urls.network) lines.push('  Network ' + urls.network);
@@ -102,6 +105,17 @@ export function openInBrowser(url) {
   }
 }
 
+export function listenError(error, { host, port, pid = null } = {}) {
+  if (error?.code === 'EADDRINUSE') {
+    const owner = pid ? ` Another Onboarder process is running as PID ${pid}.` : '';
+    return new Error(`${host}:${port} is already in use.${owner} Try \`onboarder status\`, \`onboarder stop\`, or choose another port with \`onboarder config set port <number>\`.`, { cause: error });
+  }
+  if (error?.code === 'EACCES') {
+    return new Error(`Cannot bind ${host}:${port}: permission denied. Ports below 1024 normally require elevated privileges; choose a port above 1024.`, { cause: error });
+  }
+  return error;
+}
+
 // The real boot: read the settings, bind what they say, print the banner.
 // Both `node server/index.js` and `onboarder start` land here.
 export async function startServer({ configFile = configPath(), openBrowser, log = console.log } = {}) {
@@ -130,10 +144,24 @@ export async function startServer({ configFile = configPath(), openBrowser, log
     });
   }
 
-  await new Promise((resolve, reject) => {
-    server.once('error', reject);
-    server.listen(port, host, resolve);
-  });
+  try {
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(port, host, resolve);
+    });
+  } catch (error) {
+    const recorded = readPidFile(configFile);
+    throw listenError(error, { host, port, pid: recorded && pidIsAlive(recorded) ? recorded : null });
+  }
+
+  try {
+    writePidFile(configFile);
+    server.once('close', () => removePidFile(configFile));
+    process.once('exit', () => removePidFile(configFile));
+  } catch {
+    // The server is useful even when a read-only config directory cannot hold
+    // the optional process record; binding and serving are the real contract.
+  }
 
   log(startupBanner(live, { configFile }));
 

package/server/mcp/analysis.js

@@ -206,4 +206,3 @@ export {
   docFileRow, fileFactsLine, fileStaticDoc, folderStaticDoc,
   searchDocuments,
 };
-

package/server/pidfile.js

@@ -0,0 +1,49 @@
+// Who is serving? One small file next to the config: `onboarder.pid`.
+//
+// The auto-open flow starts the server detached from the terminal that asked
+// for it, which makes "is it running?" a question ps(1) answers badly. The
+// pidfile is the answer the CLI can act on: `onboarder status` reads it,
+// `onboarder stop` kills it, and a busy-port error can say "that is us,
+// pid N" instead of shrugging. Writes are best-effort — a read-only config
+// dir must never stop the server from booting.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function pidPath(configFile) {
+  return path.join(path.dirname(path.resolve(configFile)), 'onboarder.pid');
+}
+
+// The pid in the file, or null when there is no file or it is garbage. A
+// garbage file is treated as absent rather than parsed charitably — it was
+// either written by us (one integer) or it is not ours to interpret.
+export function readPidFile(configFile) {
+  try {
+    const pid = Number(fs.readFileSync(pidPath(configFile), 'utf8').trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+// Signal 0 probes existence without delivering anything. EPERM means the
+// process exists but belongs to someone else — still alive, just not ours
+// to signal.
+export function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+}
+
+export function writePidFile(configFile) {
+  fs.writeFileSync(pidPath(configFile), String(process.pid) + '\n', { mode: 0o600 });
+}
+
+// Remove the file only when it still points at `pid` — a second server that
+// rewrote the file must not lose its record because the first one exited.
+export function removePidFile(configFile, pid = process.pid) {
+  if (readPidFile(configFile) === pid) fs.rmSync(pidPath(configFile), { force: true });
+}

package/server/.fuse_hidden0000000800000001

@@ -1,36 +0,0 @@
-// HTML to readable text, for the docs fetch. Not a parser and not trying to be:
-// the output is fed to a language model as context, so what matters is that the
-// prose survives and the markup, scripts and styles do not.
-//
-// Order is the whole trick. Script and style bodies go first — their contents are
-// text, not tags, so stripping tags first would leave a page of minified
-// JavaScript behind. The title is lifted before the general tag strip, because
-// after it there is no way to tell the title from the first paragraph. Entities
-// are decoded last, so a `<script>` written *about* HTML in the docs
-// cannot turn back into markup that the earlier passes would have removed.
-
-// Enough context for a model to summarise from without sending a whole site.
-const MAX_TEXT = 14000;
-
-const ENTITIES = {
-  '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&#39;': "'",
-};
-
-export function htmlToText(html, limit = MAX_TEXT) {
-  let s = String(html);
-  s = s.replace(/<script[\s\S]*?<\/script>/gi, ' ');
-  s = s.replace(/<style[\s\S]*?<\/style>/gi, ' ');
-
-  const rawTitle = (s.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [, ''])[1];
-  const title = collapse(rawTitle.replace(/<[^>]+>/g, ' '));
-
-  s = s.replace(/<[^>]+>/g, ' ');
-  s = s.replace(/&nbsp;|&amp;|&lt;|&gt;|&quot;|&#39;/g, (m) => ENTITIES[m]);
-  // Horizontal whitespace collapses but newlines survive as paragraph breaks:
-  // a docs page read as one long line loses the structure a summary needs.
-  s = s.replace(/[ \t ]+/g, ' ').replace(/\n\s*\n+/g, '\n\n').trim();
-
-  return { title, text: s.slice(0, limit) };
-}
-
-const collapse = (s) => s.replace(/\s+/g, ' ').trim();