termsearch 0.3.0

package/src/autostart/manager.js

@@ -0,0 +1,207 @@
+// Autostart manager — enable/disable TermSearch at boot
+// Supports: Termux (Termux:Boot), Linux (systemd --user), macOS (launchd)
+
+import { execSync, execFileSync } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+
+// ── Platform detection ────────────────────────────────────────────────────
+
+export function detectPlatform() {
+  if (process.env.PREFIX?.includes('com.termux') || fs.existsSync('/data/data/com.termux')) {
+    return 'termux';
+  }
+  if (process.platform === 'darwin') return 'macos';
+  if (process.platform === 'linux') return 'linux';
+  return 'unsupported';
+}
+
+// ── Binary path ───────────────────────────────────────────────────────────
+
+function findBin() {
+  try {
+    return execSync('which termsearch', { encoding: 'utf8' }).trim();
+  } catch {
+    return 'termsearch'; // fallback: hope it's in PATH
+  }
+}
+
+// ── Termux (Termux:Boot) ──────────────────────────────────────────────────
+
+const TERMUX_BOOT_DIR  = path.join(os.homedir(), '.termux', 'boot');
+const TERMUX_BOOT_FILE = path.join(TERMUX_BOOT_DIR, 'termsearch.sh');
+
+function termuxStatus() {
+  const bootAppInstalled = fs.existsSync(TERMUX_BOOT_DIR);
+  const enabled = fs.existsSync(TERMUX_BOOT_FILE);
+  return {
+    platform: 'termux',
+    enabled,
+    method: 'Termux:Boot',
+    config_path: TERMUX_BOOT_FILE,
+    note: bootAppInstalled
+      ? null
+      : 'Install Termux:Boot from F-Droid to enable autostart',
+    available: bootAppInstalled,
+  };
+}
+
+function termuxEnable() {
+  fs.mkdirSync(TERMUX_BOOT_DIR, { recursive: true });
+  const bin = findBin();
+  const sh = `#!/data/data/com.termux/files/usr/bin/sh\n# TermSearch autostart\n${bin} &\n`;
+  fs.writeFileSync(TERMUX_BOOT_FILE, sh, { mode: 0o755 });
+}
+
+function termuxDisable() {
+  if (fs.existsSync(TERMUX_BOOT_FILE)) fs.unlinkSync(TERMUX_BOOT_FILE);
+}
+
+// ── Linux (systemd --user) ────────────────────────────────────────────────
+
+const SYSTEMD_DIR  = path.join(os.homedir(), '.config', 'systemd', 'user');
+const SYSTEMD_FILE = path.join(SYSTEMD_DIR, 'termsearch.service');
+
+function systemdAvailable() {
+  try {
+    execSync('systemctl --user status > /dev/null 2>&1', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function systemdEnabled() {
+  try {
+    const out = execSync('systemctl --user is-enabled termsearch 2>/dev/null', { encoding: 'utf8' });
+    return out.trim() === 'enabled';
+  } catch {
+    return false;
+  }
+}
+
+function linuxStatus() {
+  const available = systemdAvailable();
+  return {
+    platform: 'linux',
+    enabled: available ? systemdEnabled() : fs.existsSync(SYSTEMD_FILE),
+    method: 'systemd --user',
+    config_path: SYSTEMD_FILE,
+    note: available ? null : 'systemd --user not available on this system',
+    available,
+  };
+}
+
+function linuxEnable() {
+  const bin = findBin();
+  fs.mkdirSync(SYSTEMD_DIR, { recursive: true });
+  const unit = [
+    '[Unit]',
+    'Description=TermSearch personal search engine',
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `ExecStart=${bin}`,
+    'Restart=on-failure',
+    'RestartSec=5',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+  ].join('\n') + '\n';
+  fs.writeFileSync(SYSTEMD_FILE, unit);
+  try {
+    execFileSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    execFileSync('systemctl', ['--user', 'enable', 'termsearch'], { stdio: 'ignore' });
+    execFileSync('systemctl', ['--user', 'start', 'termsearch'], { stdio: 'ignore' });
+  } catch { /* daemon-reload may fail in containers — file is written */ }
+}
+
+function linuxDisable() {
+  try {
+    execFileSync('systemctl', ['--user', 'stop', 'termsearch'], { stdio: 'ignore' });
+    execFileSync('systemctl', ['--user', 'disable', 'termsearch'], { stdio: 'ignore' });
+  } catch { /* ignore */ }
+  if (fs.existsSync(SYSTEMD_FILE)) fs.unlinkSync(SYSTEMD_FILE);
+}
+
+// ── macOS (launchd) ───────────────────────────────────────────────────────
+
+const LAUNCHD_DIR  = path.join(os.homedir(), 'Library', 'LaunchAgents');
+const LAUNCHD_FILE = path.join(LAUNCHD_DIR, 'com.termsearch.plist');
+const PLIST_LABEL  = 'com.termsearch';
+
+function macosStatus() {
+  const enabled = fs.existsSync(LAUNCHD_FILE);
+  return {
+    platform: 'macos',
+    enabled,
+    method: 'launchd (LaunchAgent)',
+    config_path: LAUNCHD_FILE,
+    note: null,
+    available: true,
+  };
+}
+
+function macosEnable() {
+  const bin = findBin();
+  fs.mkdirSync(LAUNCHD_DIR, { 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>${bin}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${os.homedir()}/.termsearch/termsearch.log</string>
+  <key>StandardErrorPath</key>
+  <string>${os.homedir()}/.termsearch/termsearch.log</string>
+</dict>
+</plist>
+`;
+  fs.writeFileSync(LAUNCHD_FILE, plist);
+  // Try modern bootstrap API first (macOS Ventura+), fallback to legacy load
+  try {
+    const uid = execSync('id -u', { encoding: 'utf8' }).trim();
+    execFileSync('launchctl', ['bootstrap', `gui/${uid}`, LAUNCHD_FILE], { stdio: 'ignore' });
+  } catch {
+    try { execFileSync('launchctl', ['load', '-w', LAUNCHD_FILE], { stdio: 'ignore' }); } catch { /* ignore */ }
+  }
+}
+
+function macosDisable() {
+  try {
+    const uid = execSync('id -u', { encoding: 'utf8' }).trim();
+    execFileSync('launchctl', ['bootout', `gui/${uid}`, LAUNCHD_FILE], { stdio: 'ignore' });
+  } catch {
+    try { execFileSync('launchctl', ['unload', '-w', LAUNCHD_FILE], { stdio: 'ignore' }); } catch { /* ignore */ }
+  }
+  if (fs.existsSync(LAUNCHD_FILE)) fs.unlinkSync(LAUNCHD_FILE);
+}
+
+// ── Public API ────────────────────────────────────────────────────────────
+
+export function getStatus() {
+  const platform = detectPlatform();
+  if (platform === 'termux') return termuxStatus();
+  if (platform === 'linux')  return linuxStatus();
+  if (platform === 'macos')  return macosStatus();
+  return { platform: 'unsupported', enabled: false, method: null, note: 'Autostart not supported on this platform', available: false };
+}
+
+export function setEnabled(enable) {
+  const platform = detectPlatform();
+  if (platform === 'termux') { enable ? termuxEnable() : termuxDisable(); return getStatus(); }
+  if (platform === 'linux')  { enable ? linuxEnable()  : linuxDisable();  return getStatus(); }
+  if (platform === 'macos')  { enable ? macosEnable()  : macosDisable();  return getStatus(); }
+  throw new Error('Autostart not supported on this platform');
+}

package/src/config/defaults.js

@@ -0,0 +1,62 @@
+// Default configuration values for TermSearch
+// These are deep-merged with user config on load, so new keys auto-appear on upgrade.
+
+export const DEFAULTS = {
+  port: 3000,
+  host: '127.0.0.1',
+
+  search: {
+    providers: ['duckduckgo', 'wikipedia'],
+    timeout_ms: 15000,
+    max_query_length: 240,
+    result_count: 10,
+    fallback_min_results: 5,
+    cache_ttl_search_ms: 720_000,   // 12 min
+    cache_ttl_doc_ms: 2_700_000,    // 45 min
+    cache_l1_max_search: 200,
+    cache_l1_max_docs: 150,
+    // Disk cache — conservative defaults for Termux/low-end devices
+    disk_max_search_entries: 1000,
+    disk_max_search_bytes: 50 * 1024 * 1024,   // 50 MB
+    disk_max_doc_entries: 1500,
+    disk_max_doc_bytes: 100 * 1024 * 1024,     // 100 MB
+  },
+
+  ai: {
+    enabled: false,
+    api_base: '',       // e.g. http://localhost:11434/v1
+    api_key: '',        // optional
+    model: '',          // e.g. qwen3:1.7b
+    max_tokens: 1200,
+    timeout_ms: 90_000,
+    rate_limit: 20,     // per hour per IP
+    rate_window_ms: 3_600_000,
+    fetch_soft_cap: 15,
+    fetch_hard_cap: 25,
+    fetch_max_per_domain: 2,
+    fetch_min_per_engine: 3,
+  },
+
+  brave: {
+    enabled: false,
+    api_key: '',
+    api_base: 'https://api.search.brave.com/res/v1',
+  },
+
+  mojeek: {
+    enabled: false,
+    api_key: '',
+    api_base: 'https://api.mojeek.com',
+  },
+
+  searxng: {
+    enabled: false,
+    url: '',  // e.g. http://localhost:9090
+  },
+
+  rate_limit: {
+    general_per_min: 45,
+    search_per_min: 30,
+    window_ms: 60_000,
+  },
+};

package/src/config/manager.js

@@ -0,0 +1,188 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { DEFAULTS } from './defaults.js';
+
+// Data directory: $TERMSEARCH_DATA_DIR or ~/.termsearch/
+function resolveDataDir() {
+  return process.env.TERMSEARCH_DATA_DIR
+    ? path.resolve(process.env.TERMSEARCH_DATA_DIR)
+    : path.join(os.homedir(), '.termsearch');
+}
+
+// Deep-merge: src values override dst, recursively for plain objects
+function deepMerge(dst, src) {
+  const out = { ...dst };
+  for (const [k, v] of Object.entries(src || {})) {
+    if (v !== null && typeof v === 'object' && !Array.isArray(v) && typeof dst[k] === 'object' && dst[k] !== null && !Array.isArray(dst[k])) {
+      out[k] = deepMerge(dst[k], v);
+    } else if (v !== undefined) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+function isMaskedValue(value) {
+  const s = String(value || '').trim();
+  return s.includes('*') || s.includes('•');
+}
+
+class ConfigManager {
+  constructor() {
+    this._dataDir = null;
+    this._config = null;
+  }
+
+  getDataDir() {
+    if (!this._dataDir) this._init();
+    return this._dataDir;
+  }
+
+  getConfig() {
+    if (!this._config) this._init();
+    return this._config;
+  }
+
+  _init() {
+    this._dataDir = resolveDataDir();
+    // Create data dir and cache subdirs on first run
+    try {
+      fs.mkdirSync(this._dataDir, { recursive: true, mode: 0o700 });
+      fs.mkdirSync(path.join(this._dataDir, 'cache', 'search'), { recursive: true, mode: 0o700 });
+      fs.mkdirSync(path.join(this._dataDir, 'cache', 'docs'), { recursive: true, mode: 0o700 });
+    } catch { /* ignore */ }
+
+    const configPath = path.join(this._dataDir, 'config.json');
+    let userConfig = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        userConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        try { fs.chmodSync(configPath, 0o600); } catch { /* ignore */ }
+      } catch {
+        console.warn('[config] Warning: could not parse config.json, using defaults');
+      }
+    } else {
+      // First run: write defaults
+      this._writeFile(configPath, DEFAULTS);
+    }
+
+    // Env var overrides (for power users / CI)
+    const envOverrides = this._readEnvOverrides();
+    this._config = deepMerge(deepMerge(DEFAULTS, userConfig), envOverrides);
+  }
+
+  _readEnvOverrides() {
+    const overrides = {};
+    if (process.env.TERMSEARCH_PORT) overrides.port = Number(process.env.TERMSEARCH_PORT);
+    if (process.env.TERMSEARCH_HOST) overrides.host = process.env.TERMSEARCH_HOST;
+    if (process.env.TERMSEARCH_AI_API_BASE) {
+      overrides.ai = { ...overrides.ai, api_base: process.env.TERMSEARCH_AI_API_BASE, enabled: true };
+    }
+    if (process.env.TERMSEARCH_AI_API_KEY) {
+      overrides.ai = { ...overrides.ai, api_key: process.env.TERMSEARCH_AI_API_KEY };
+    }
+    if (process.env.TERMSEARCH_AI_MODEL) {
+      overrides.ai = { ...overrides.ai, model: process.env.TERMSEARCH_AI_MODEL };
+    }
+    if (process.env.TERMSEARCH_BRAVE_API_KEY) {
+      overrides.brave = { api_key: process.env.TERMSEARCH_BRAVE_API_KEY, enabled: true };
+    }
+    if (process.env.TERMSEARCH_MOJEEK_API_KEY) {
+      overrides.mojeek = { api_key: process.env.TERMSEARCH_MOJEEK_API_KEY, enabled: true };
+    }
+    if (process.env.TERMSEARCH_SEARXNG_URL) {
+      overrides.searxng = { url: process.env.TERMSEARCH_SEARXNG_URL, enabled: true };
+    }
+    return overrides;
+  }
+
+  // Update config in-memory and persist to disk
+  update(partial) {
+    if (!this._config) this._init();
+    const safePartial = JSON.parse(JSON.stringify(partial || {}));
+    this._sanitizeSensitiveKeys(safePartial);
+    this._config = deepMerge(this._config, safePartial);
+    // Auto-enable AI/providers when keys are provided
+    if (safePartial?.ai?.api_base && !safePartial?.ai?.hasOwnProperty('enabled')) {
+      this._config.ai.enabled = Boolean(this._config.ai.api_base);
+    }
+    if (safePartial?.brave?.api_key && !safePartial?.brave?.hasOwnProperty('enabled')) {
+      this._config.brave.enabled = Boolean(this._config.brave.api_key);
+    }
+    if (safePartial?.mojeek?.api_key && !safePartial?.mojeek?.hasOwnProperty('enabled')) {
+      this._config.mojeek.enabled = Boolean(this._config.mojeek.api_key);
+    }
+    if (safePartial?.searxng?.url && !safePartial?.searxng?.hasOwnProperty('enabled')) {
+      this._config.searxng.enabled = Boolean(this._config.searxng.url);
+    }
+    this._persist();
+  }
+
+  _sanitizeSensitiveKeys(partial) {
+    const sections = ['ai', 'brave', 'mojeek'];
+    for (const section of sections) {
+      const block = partial?.[section];
+      if (!block || typeof block !== 'object' || !Object.prototype.hasOwnProperty.call(block, 'api_key')) continue;
+      const incoming = block.api_key;
+      if (incoming == null) {
+        delete block.api_key;
+        continue;
+      }
+      const raw = String(incoming);
+      const trimmed = raw.trim();
+      if (trimmed === '') {
+        block.api_key = '';
+        continue;
+      }
+      // UI placeholders like sk-****1234 must never overwrite the stored secret
+      if (isMaskedValue(trimmed)) {
+        block.api_key = this._config?.[section]?.api_key || '';
+      }
+    }
+  }
+
+  _persist() {
+    const configPath = path.join(this._dataDir, 'config.json');
+    // Don't persist env overrides — only persist what the user explicitly set via web UI
+    const toSave = this._stripSensitiveForPersist(this._config);
+    this._writeFile(configPath, toSave);
+  }
+
+  _stripSensitiveForPersist(config) {
+    // Persist everything — env overrides will re-apply on next startup
+    return JSON.parse(JSON.stringify(config));
+  }
+
+  _writeFile(filePath, data) {
+    const tmp = filePath + '.tmp';
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
+      fs.renameSync(tmp, filePath);
+      fs.chmodSync(filePath, 0o600);
+    } catch (e) {
+      console.warn('[config] Could not write config file:', e.message);
+    }
+  }
+
+  // Returns config with API keys masked for public display
+  getPublicConfig() {
+    const c = this.getConfig();
+    return {
+      ...c,
+      ai: { ...c.ai, api_key: maskKey(c.ai.api_key) },
+      brave: { ...c.brave, api_key: maskKey(c.brave.api_key) },
+      mojeek: { ...c.mojeek, api_key: maskKey(c.mojeek.api_key) },
+    };
+  }
+}
+
+function maskKey(key) {
+  if (!key) return '';
+  if (key.length <= 8) return '****';
+  return `${key.slice(0, 4)}****${key.slice(-4)}`;
+}
+
+// Singleton
+export const config = new ConfigManager();
+export default config;