crucix 2.39.3 → 2.39.5

package/README.md

@@ -94,16 +94,31 @@ It was built for anyone who wants to understand what's actually happening in the
 
 ## Quick Start
 
+```powershell
+# Windows: standalone exe from GitHub Releases (no Node)
+irm https://github.com/arlinamid/Crucix/releases/latest/download/install.ps1 | iex
+```
+
+```bash
+# Linux / macOS
+curl -fsSL https://github.com/arlinamid/Crucix/releases/latest/download/install.sh | sh
+```
+
 ```bash
-# From npm (recommended): Node + runtime source, first run opens the setup wizard
+# From npm: Node + runtime source, first run opens the setup wizard
 npx crucix
 npm install -g crucix
+```
+
+Then:
+
+```bash
 crucix --version
 crucix install          # ~/.crucix (.env and runs/)
 crucix                  # dashboard; wizard if no .env yet
 ```
 
-That is not the standalone exe. `npm run install:local` (from a git checkout) builds `crucix.exe` and copies it to `%USERPROFILE%\.local\bin` / `~/.local/bin`. Check which one PATH hits with `crucix --version`.
+`npm run install:local` (from a git checkout) builds the exe yourself. Check which one PATH hits with `crucix --version`.
 
 Settings the wizard and **Settings → News feeds** save go to `%USERPROFILE%\.crucix` on Windows or `~/.crucix` on Linux/macOS. Set `CRUCIX_HOME` to choose another folder, or `CRUCIX_ENV_FILE` to name the `.env` itself.
 

package/apis/utils/rss-pool.mjs

@@ -10,6 +10,12 @@ export const RSS_TIMEOUT_MS = 12000;
 export const rssAgent = new Agent({
   connections: RSS_CONCURRENCY,
   pipelining: 0,
+  // Close the socket after each feed. Reusing a TLS connection that AbortSignal
+  // paused makes Node's HTTP parser throw assert(!this.paused) on socket end.
+  keepAliveTimeout: 1,
+  keepAliveMaxTimeout: 1,
+  bodyTimeout: RSS_TIMEOUT_MS,
+  headersTimeout: RSS_TIMEOUT_MS,
   connect: {
     timeout: 8000,
     family: 4,

package/lib/http-parser-error.mjs

@@ -0,0 +1,10 @@
+// Node/undici can throw AssertionError `assert(!this.paused)` from Parser.finish when a
+// TLS socket ends after AbortSignal paused the HTTP parser (RSS timeouts). The sweep
+// already treated that feed as failed; the process must keep running.
+
+export function isBenignHttpParserClose(error) {
+  if (!error || error.name !== 'AssertionError') return false;
+  const message = String(error.message || '');
+  const stack = String(error.stack || '');
+  return message.includes('assert(!this.paused)') && (stack.includes('Parser.finish') || stack.includes('onHttpSocketEnd'));
+}

package/lib/instance-lock.mjs

@@ -0,0 +1,81 @@
+// One long-running Crucix (dashboard or --collector) per runs/ profile.
+// A second copy would share AIS, daily quotas and the same latest.json.
+
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const INSTANCE_LOCK_NAME = 'instance.lock';
+
+export function instanceLockPath(runsDir) {
+  return join(runsDir, INSTANCE_LOCK_NAME);
+}
+
+export function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+export function acquireInstanceLock(runsDir, { pid = process.pid, now = Date.now() } = {}) {
+  if (!runsDir) throw new TypeError('runsDir is required');
+  mkdirSync(runsDir, { recursive: true });
+  const path = instanceLockPath(runsDir);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(path, 'wx');
+      try {
+        writeFileSync(fd, `${JSON.stringify({ pid, startedAt: new Date(now).toISOString() })}\n`);
+      } finally {
+        closeSync(fd);
+      }
+      return { path, pid, created: true };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error;
+      let other = null;
+      try { other = JSON.parse(readFileSync(path, 'utf8')); } catch { /* replace a corrupt lock */ }
+      if (Number(other?.pid) === pid) return { path, pid, created: false };
+      if (processIsAlive(Number(other?.pid))) {
+        return { error: 'already_running', pid: Number(other.pid), startedAt: other.startedAt || null, path };
+      }
+      try { unlinkSync(path); } catch { /* another process won the unlink */ }
+    }
+  }
+  return { error: 'already_running', path };
+}
+
+export function releaseInstanceLock(runsDir, { pid = process.pid } = {}) {
+  const path = instanceLockPath(runsDir);
+  if (!existsSync(path)) return false;
+  try {
+    const other = JSON.parse(readFileSync(path, 'utf8'));
+    if (Number(other?.pid) !== pid) return false;
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function holdInstanceLock(runsDir, { exit = (code) => process.exit(code) } = {}) {
+  const lock = acquireInstanceLock(runsDir);
+  if (lock.error) return lock;
+  const release = () => { try { releaseInstanceLock(runsDir); } catch { /* process is leaving */ } };
+  process.on('exit', release);
+  for (const signal of ['SIGINT', 'SIGTERM']) {
+    process.on(signal, () => { release(); exit(0); });
+  }
+  return lock;
+}
+
+export function alreadyRunningMessage(lock, { port, lang = 'en' } = {}) {
+  const pid = lock?.pid ? ` (pid ${lock.pid})` : '';
+  const where = port ? ` http://localhost:${port}` : '';
+  if (lang === 'hu') {
+    return `[Crucix] FATAL: már fut egy példány${pid}.${where ? ` Dashboard:${where}` : ''} Állítsd le azt, mielőtt újat indítasz.`;
+  }
+  return `[Crucix] FATAL: already running${pid}.${where ? ` Dashboard:${where}` : ''} Stop that instance before starting another.`;
+}

package/lib/release-binary.mjs

@@ -0,0 +1,32 @@
+// Names of the GitHub Release assets that `scripts/build-exe.mjs` and CI upload.
+// install.ps1 / install.sh must stay in lockstep with this map.
+
+const OS = Object.freeze({ win32: 'windows', linux: 'linux', darwin: 'macos' });
+const ARCH = Object.freeze({ x64: 'x64', arm64: 'arm64' });
+
+export function releaseAssetName(platform = process.platform, arch = process.arch) {
+  const os = OS[platform];
+  const cpu = ARCH[arch];
+  if (!os || !cpu) return null;
+  return `crucix-${os}-${cpu}${os === 'windows' ? '.exe' : ''}`;
+}
+
+export function installedBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'crucix.exe' : 'crucix';
+}
+
+export function checksumFor(sumsText, filename) {
+  if (!sumsText || !filename) return null;
+  for (const line of String(sumsText).split(/\r?\n/)) {
+    const match = line.match(/^([a-fA-F0-9]{64})\s+(\S+)\s*$/);
+    if (match && match[2] === filename) return match[1].toLowerCase();
+  }
+  return null;
+}
+
+export function releaseDownloadUrl(repo, tag, filename) {
+  const ownerRepo = repo || 'arlinamid/Crucix';
+  const ref = !tag || tag === 'latest' ? 'latest' : tag;
+  const path = ref === 'latest' ? 'latest/download' : `download/${ref}`;
+  return `https://github.com/${ownerRepo}/releases/${path}/${filename}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crucix",
-  "version": "2.39.3",
+  "version": "2.39.5",
   "description": "Local intelligence engine - 52 OSINT adapters, live dashboard, bounded requests, optional local or cloud AI.",
   "type": "module",
   "bin": {

package/scripts/cli.mjs

@@ -22,6 +22,7 @@ import { getEnvSearchPaths } from '../apis/utils/env.mjs';
 import { installUserProfile } from '../lib/profile-install.mjs';
 import { resolveRunsDir as resolveUserRunsDir } from '../lib/user-paths.mjs';
 import { packageVersion, versionLine } from '../lib/version.mjs';
+import { alreadyRunningMessage, holdInstanceLock } from '../lib/instance-lock.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, '..');
@@ -1578,6 +1579,11 @@ async function main() {
 
   // 0b. Continuous data collector loop without any web server
   if (opts.collector) {
+    const lock = holdInstanceLock(runsDir);
+    if (lock.error) {
+      console.error(alreadyRunningMessage(lock, { port, lang }));
+      process.exit(1);
+    }
     const intervalMinutes = opts.interval || 15;
     if (lang === 'hu') {
       console.log('\n🔄 Crucix Folyamatos Adatgyűjtő Ciklus (Headless Collector)');

package/scripts/install.ps1

@@ -0,0 +1,76 @@
+# Crucix standalone installer (Windows x64). Node is not required.
+#   irm https://github.com/arlinamid/Crucix/releases/latest/download/install.ps1 | iex
+# Pin a tag:  $env:CRUCIX_VERSION = 'v2.39.3'; irm ... | iex
+# Dest:       $env:CRUCIX_BIN (default %USERPROFILE%\.local\bin)
+
+$ErrorActionPreference = 'Stop'
+$repo = if ($env:CRUCIX_REPO) { $env:CRUCIX_REPO } else { 'arlinamid/Crucix' }
+$tag = if ($env:CRUCIX_VERSION) { $env:CRUCIX_VERSION } else { 'latest' }
+$binDir = if ($env:CRUCIX_BIN) { $env:CRUCIX_BIN } else { Join-Path $env:USERPROFILE '.local\bin' }
+
+$arch = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }
+if ($arch -eq 'AMD64') { $cpu = 'x64' }
+elseif ($arch -eq 'ARM64') { $cpu = 'arm64' }
+else { throw "Unsupported Windows architecture: $arch" }
+
+$asset = "crucix-windows-$cpu.exe"
+if ($cpu -ne 'x64') {
+  throw "This release has no Windows $cpu binary yet. Use an x64 machine or build from source (npm run install:local)."
+}
+
+$base = if ($tag -eq 'latest') {
+  "https://github.com/$repo/releases/latest/download"
+} else {
+  if ($tag -notmatch '^v') { $tag = "v$tag" }
+  "https://github.com/$repo/releases/download/$tag"
+}
+
+$tmp = Join-Path ([System.IO.Path]::GetTempPath()) ("crucix-dl-" + [guid]::NewGuid().ToString('n'))
+New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+$exeTmp = Join-Path $tmp $asset
+$sumsTmp = Join-Path $tmp 'SHA256SUMS.txt'
+
+Write-Host "Crucix standalone install"
+Write-Host "  source  $base/$asset"
+Write-Host "  dest    $(Join-Path $binDir 'crucix.exe')"
+
+try {
+  try {
+    Invoke-WebRequest -Uri "$base/$asset" -OutFile $exeTmp -UseBasicParsing
+    Invoke-WebRequest -Uri "$base/SHA256SUMS.txt" -OutFile $sumsTmp -UseBasicParsing
+  } catch {
+    throw "Download failed. Check $base/$asset ($($_.Exception.Message))"
+  }
+
+$actual = (Get-FileHash -Algorithm SHA256 -Path $exeTmp).Hash.ToLowerInvariant()
+$expected = $null
+foreach ($line in Get-Content $sumsTmp) {
+  if ($line -match '^([a-fA-F0-9]{64})\s+(\S+)\s*$' -and $Matches[2] -eq $asset) {
+    $expected = $Matches[1].ToLowerInvariant()
+    break
+  }
+}
+if (-not $expected) { throw "SHA256SUMS.txt has no entry for $asset" }
+if ($actual -ne $expected) { throw "Checksum mismatch for $asset`n  expected $expected`n  got      $actual" }
+Write-Host "  sha256  $actual"
+
+New-Item -ItemType Directory -Force -Path $binDir | Out-Null
+$target = Join-Path $binDir 'crucix.exe'
+Copy-Item -Force $exeTmp $target
+Set-Content -Path (Join-Path $binDir 'crucix.cmd') -Value "@echo off`r`n`"%~dp0crucix.exe`" %*`r`n" -Encoding ascii
+$sh = "#!/usr/bin/env sh`nbasedir=`$(dirname `"`$0`")`nexec `"`$basedir/crucix.exe`" `"`$@`"`n"
+Set-Content -Path (Join-Path $binDir 'crucix') -Value $sh -Encoding ascii
+
+$onPath = ($env:PATH -split ';' | ForEach-Object { $_.TrimEnd('\') }) -contains $binDir.TrimEnd('\')
+Write-Host ""
+Write-Host "Installed $target"
+if (-not $onPath) {
+  Write-Host "Add this folder to PATH, then open a new terminal:"
+  Write-Host "  $binDir"
+}
+Write-Host "  crucix --version"
+Write-Host "  crucix install --no-setup"
+Write-Host "  crucix setup"
+} finally {
+  Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue
+}

package/scripts/install.sh

@@ -0,0 +1,80 @@
+#!/bin/sh
+# Crucix standalone installer (Linux x64, macOS arm64). Node is not required.
+#   curl -fsSL https://github.com/arlinamid/Crucix/releases/latest/download/install.sh | sh
+# Pin a tag:  CRUCIX_VERSION=v2.39.3 curl -fsSL ... | sh
+# Dest:       CRUCIX_BIN (default ~/.local/bin)
+
+set -eu
+REPO="${CRUCIX_REPO:-arlinamid/Crucix}"
+TAG="${CRUCIX_VERSION:-latest}"
+BIN_DIR="${CRUCIX_BIN:-$HOME/.local/bin}"
+
+os=$(uname -s)
+arch=$(uname -m)
+case "$os" in
+  Linux)  os_name=linux ;;
+  Darwin) os_name=macos ;;
+  *) echo "Unsupported OS: $os" >&2; exit 1 ;;
+esac
+case "$arch" in
+  x86_64|amd64) cpu=x64 ;;
+  arm64|aarch64) cpu=arm64 ;;
+  *) echo "Unsupported architecture: $arch" >&2; exit 1 ;;
+esac
+
+ASSET="crucix-${os_name}-${cpu}"
+if [ "$TAG" != latest ] && ! echo "$TAG" | grep -q '^v'; then
+  TAG="v$TAG"
+fi
+if [ "$TAG" = latest ]; then
+  BASE="https://github.com/${REPO}/releases/latest/download"
+else
+  BASE="https://github.com/${REPO}/releases/download/${TAG}"
+fi
+
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+echo "Crucix standalone install"
+echo "  source  ${BASE}/${ASSET}"
+echo "  dest    ${BIN_DIR}/crucix"
+
+if ! curl -fsSL "${BASE}/${ASSET}" -o "${TMP}/${ASSET}"; then
+  echo "Download failed. This release may not have ${ASSET}." >&2
+  exit 1
+fi
+curl -fsSL "${BASE}/SHA256SUMS.txt" -o "${TMP}/SHA256SUMS.txt"
+
+if command -v sha256sum >/dev/null 2>&1; then
+  ACTUAL=$(sha256sum "${TMP}/${ASSET}" | awk '{print $1}')
+elif command -v shasum >/dev/null 2>&1; then
+  ACTUAL=$(shasum -a 256 "${TMP}/${ASSET}" | awk '{print $1}')
+else
+  echo "Need sha256sum or shasum to verify the download." >&2
+  exit 1
+fi
+EXPECTED=$(awk -v f="$ASSET" '$2==f {print $1; exit}' "${TMP}/SHA256SUMS.txt" | tr 'A-F' 'a-f')
+if [ -z "$EXPECTED" ]; then
+  echo "SHA256SUMS.txt has no entry for ${ASSET}" >&2
+  exit 1
+fi
+if [ "$ACTUAL" != "$EXPECTED" ]; then
+  echo "Checksum mismatch for ${ASSET}" >&2
+  echo "  expected ${EXPECTED}" >&2
+  echo "  got      ${ACTUAL}" >&2
+  exit 1
+fi
+echo "  sha256  ${ACTUAL}"
+
+mkdir -p "$BIN_DIR"
+cp "${TMP}/${ASSET}" "${BIN_DIR}/crucix"
+chmod 755 "${BIN_DIR}/crucix"
+
+echo
+echo "Installed ${BIN_DIR}/crucix"
+case ":$PATH:" in
+  *":${BIN_DIR}:"*) ;;
+  *) echo "Add this folder to PATH, then open a new terminal:"; echo "  ${BIN_DIR}" ;;
+esac
+echo "  crucix --version"
+echo "  crucix install --no-setup"
+echo "  crucix setup"

package/server.mjs

@@ -54,6 +54,8 @@ import { openFeedStore, setActiveFeedStore } from './lib/news/feed-store.mjs';
 import { installFeedRoutes } from './lib/news/routes.mjs';
 import { resolveRunsDir as resolveUserRunsDir, feedsSettingsPath, settingsEnvPath } from './lib/user-paths.mjs';
 import { resolveDashboardPublicDir, readJarvisHtml } from './lib/dashboard-path.mjs';
+import { alreadyRunningMessage, holdInstanceLock } from './lib/instance-lock.mjs';
+import { isBenignHttpParserClose } from './lib/http-parser-error.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = __dirname;
@@ -579,6 +581,12 @@ async function runSweepCycle() {
 
 // === Startup ===
 async function start() {
+  const lock = holdInstanceLock(RUNS_DIR);
+  if (lock.error) {
+    console.error(alreadyRunningMessage(lock, { port: config.port, lang: currentLanguage }));
+    process.exit(1);
+  }
+
   const port = config.port;
 
   const isHeadless =
@@ -672,7 +680,15 @@ async function start() {
 process.on('unhandledRejection', (err) => {
   console.error('[Crucix] Unhandled rejection:', err?.stack || err?.message || err);
 });
+let httpParserCloseWarned = false;
 process.on('uncaughtException', (err) => {
+  if (isBenignHttpParserClose(err)) {
+    if (!httpParserCloseWarned) {
+      httpParserCloseWarned = true;
+      console.warn('[Crucix] Node HTTP parser hit a paused TLS socket (RSS abort). Continuing; this is not a sweep failure.');
+    }
+    return;
+  }
   console.error('[Crucix] Uncaught exception:', err?.stack || err?.message || err);
 });