@agentsoc/beacon 0.0.1 → 0.0.2

package/README.md

@@ -12,50 +12,36 @@ The Syslog Beacon CLI allows you to configure, install, and run a lightweight lo
 
 ## Installation
 
-### 🚀 Quick Install (One-Line Commands)
+Installers are **hosted on the marketing site** (not duplicated in this repo):
 
-#### macOS / Linux
+| Method | URL / command |
+|--------|----------------|
+| **macOS / Linux (curl)** | `curl -fsSL https://agentsoc.com/connectors/beacon.sh \| bash` |
+| **Windows PowerShell** | `irm https://agentsoc.com/connectors/beacon-install.ps1 \| iex` |
+| **Windows (batch)** | Download and run [beacon-install.bat](https://agentsoc.com/connectors/beacon-install.bat) |
+| **npm** | `npm install -g @agentsoc/beacon` |
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/yourusername/platform.agentsoc.com/main/apps/connectors/syslog-beacon-cli/install.sh | bash
-```
-
-#### Windows PowerShell
-
-```powershell
-irm https://raw.githubusercontent.com/yourusername/platform.agentsoc.com/main/apps/connectors/syslog-beacon-cli/install.ps1 | iex
-```
-
-#### Standard npm
-
-Published as [`@agentsoc/beacon`](https://www.npmjs.com/package/@agentsoc/beacon) (npm requires a lowercase scope; same AgentSOC package).
-
-```bash
-npm install -g @agentsoc/beacon
-```
+Published package: [`@agentsoc/beacon`](https://www.npmjs.com/package/@agentsoc/beacon) (npm scope is lowercase `agentsoc`).
 
 The `syslog-beacon` command is also installed as an alias for the same CLI.
 
-### Option 2: Run from source with Bun
+### Run from source (this monorepo)
 
 If you have the repository cloned and [Bun](https://bun.sh/) installed:
 
 ```bash
 cd apps/connectors/syslog-beacon-cli
 bun install
-bun run src/cli.ts config --url <url> --key <key>
-bun run src/cli.ts run
+bun run build:simple
+npm install -g .
 ```
 
-### Installation Scripts
-
-Automated installation scripts are provided for easy setup:
+Then use `beacon` / `syslog-beacon` like a normal global install:
 
-- **`install.sh`** - macOS/Linux installer
-- **`install.ps1`** - Windows PowerShell installer
-- **`install.bat`** - Windows batch installer
-
-These scripts automatically check for Node.js/npm, install the package, and verify the installation.
+```bash
+beacon config --url <url> --key <key>
+beacon run
+```
 
 ## Usage
 
@@ -115,34 +101,22 @@ beacon install
 
 - Start the daemon using npm script: `npm start` or `bun run start`
 - Install service using npm script: `npm run install-service` or `bun run install-service`
-- Build the distributable: `npm run build:simple` (compiles TypeScript to dist/)
-
-## Building & Distribution
+- Build the distributable: `npm run build:simple` (compiles TypeScript to `dist/`)
 
-### Build the Package
+## Building & distribution
 
-To build the TypeScript files into the `dist/` folder:
+### Build the package
 
 ```bash
 npm run build:simple
 ```
 
-### Share Installation Scripts
+### Publish to npm
 
-Users can install the package using one of the provided installation scripts:
-
-- Copy the `install.sh` script to your repository (macOS/Linux users)
-- Copy the `install.ps1` script to your repository (Windows PowerShell users)
-- Copy the `install.bat` script to your repository (Windows batch users)
-
-Users can then run:
+From this directory, after bumping `version` in `package.json`:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/yourusername/platform.agentsoc.com/main/apps/connectors/syslog-beacon-cli/install.sh | bash
+npm publish --access public
 ```
 
-Or use npm:
-
-```bash
-npm install -g @agentsoc/beacon
-```
+Public install entrypoints live under **`https://agentsoc.com/connectors/`** (`beacon.sh`, `beacon-install.ps1`, `beacon-install.bat`).

package/dist/cli.js

@@ -3,6 +3,8 @@ import { Command } from "commander";
 import { loadConfig, saveConfig } from "./config.js";
 import { runBeacon } from "./run-beacon.js";
 import { installService } from "./service-install.js";
+import { probeServiceStatus } from "./service-status.js";
+import { getStatsFilePath, readStats } from "./stats.js";
 const program = new Command();
 program
     .name("beacon")
@@ -43,6 +45,39 @@ program
         process.exit(1);
     }
 });
+program
+    .command("status")
+    .description("Show service state and forwarding statistics")
+    .action(async () => {
+    const svc = probeServiceStatus();
+    const stats = await readStats();
+    const statsPath = getStatsFilePath();
+    console.log("\n[beacon] Status\n");
+    console.log(`  Service (${svc.manager}): ${svc.installed ? svc.stateLabel : "not installed"}`);
+    if (svc.active === true)
+        console.log("  Running: yes");
+    else if (svc.active === false)
+        console.log("  Running: no");
+    else
+        console.log("  Running: n/a");
+    if (svc.detail)
+        console.log(`  Note: ${svc.detail}`);
+    console.log("\n  Forwarding (from this machine's beacon stats file):");
+    console.log(`  Stats file: ${statsPath}`);
+    console.log(`  Log entries forwarded (successful): ${stats.logsForwarded}`);
+    console.log(`  Successful batches: ${stats.batchesSucceeded}`);
+    console.log(`  Failed batches: ${stats.batchesFailed}`);
+    if (stats.updatedAt && stats.updatedAt !== new Date(0).toISOString()) {
+        console.log(`  Last stats update: ${stats.updatedAt}`);
+    }
+    else {
+        console.log("  Last stats update: (never - no successful forwards yet)");
+    }
+    if (stats.lastError) {
+        console.log(`  Last error: ${stats.lastError}`);
+    }
+    console.log("\n  If the service runs as another user (e.g. root), stats may be under that user's config directory.\n");
+});
 program
     .command("run")
     .description("Run the forwarder daemon (foreground)")

package/dist/forwarder.js

@@ -1,3 +1,4 @@
+import { recordFailedBatch, recordSuccessfulBatch } from "./stats.js";
 function parseSyslogPri(line) {
     // Default mapping if line does not start with <PRI>
     let severity = 5; // notice (maps to 'low' severity in our logic)
@@ -114,14 +115,18 @@ export class Forwarder {
             });
             if (!res.ok) {
                 const text = await res.text();
+                const msg = `HTTP ${res.status} ${text}`;
                 console.error(`[syslog-beacon] Failed to push logs: HTTP ${res.status} ${text}`);
+                await recordFailedBatch(msg);
             }
             else {
                 console.log(`[syslog-beacon] Successfully pushed ${payload.length} logs`);
+                await recordSuccessfulBatch(payload.length);
             }
         }
         catch (err) {
             console.error(`[syslog-beacon] Ingest error:`, err);
+            await recordFailedBatch(err instanceof Error ? err.message : String(err));
         }
     }
     async stop() {

package/dist/service-status.js

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+function trimDetail(s, max = 200) {
+    const one = s.replace(/\s+/g, " ").trim();
+    return one.length <= max ? one : `${one.slice(0, max)}…`;
+}
+export function probeServiceStatus() {
+    if (process.platform === "linux") {
+        const unitPath = "/etc/systemd/system/syslog-beacon.service";
+        const installed = fs.existsSync(unitPath);
+        if (!installed) {
+            return {
+                manager: "systemd",
+                installed: false,
+                active: null,
+                stateLabel: "not installed",
+                detail: "No unit at /etc/systemd/system/syslog-beacon.service",
+            };
+        }
+        try {
+            const out = execFileSync("systemctl", ["is-active", "syslog-beacon"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "pipe"],
+            }).trim();
+            const active = out === "active";
+            return {
+                manager: "systemd",
+                installed: true,
+                active,
+                stateLabel: out || "unknown",
+            };
+        }
+        catch (err) {
+            const status = err.status;
+            const stderr = err.stderr?.toString?.() ?? "";
+            if (status === 3) {
+                return {
+                    manager: "systemd",
+                    installed: true,
+                    active: false,
+                    stateLabel: "inactive",
+                };
+            }
+            return {
+                manager: "systemd",
+                installed: true,
+                active: false,
+                stateLabel: "unknown",
+                detail: trimDetail(stderr || String(err)),
+            };
+        }
+    }
+    if (process.platform === "darwin") {
+        const plistPath = "/Library/LaunchDaemons/com.agentsoc.syslog-beacon.plist";
+        const installed = fs.existsSync(plistPath);
+        if (!installed) {
+            return {
+                manager: "launchd",
+                installed: false,
+                active: null,
+                stateLabel: "not installed",
+                detail: `No plist at ${plistPath}`,
+            };
+        }
+        try {
+            const out = execFileSync("launchctl", ["print", "system/com.agentsoc.syslog-beacon"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+            const m = out.match(/^\s*state\s*=\s*(\S+)/m);
+            const state = m?.[1] ?? "unknown";
+            const active = state === "running";
+            return {
+                manager: "launchd",
+                installed: true,
+                active,
+                stateLabel: state,
+            };
+        }
+        catch (err) {
+            const stderr = err.stderr?.toString?.() ?? "";
+            return {
+                manager: "launchd",
+                installed: true,
+                active: null,
+                stateLabel: "unknown",
+                detail: trimDetail(stderr || String(err)),
+            };
+        }
+    }
+    return {
+        manager: "none",
+        installed: false,
+        active: null,
+        stateLabel: "unsupported",
+        detail: "Automatic service detection is only available on Linux (systemd) and macOS (launchd).",
+    };
+}

package/dist/stats.js

@@ -0,0 +1,71 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getConfigDir } from "./config.js";
+const STATS_VERSION = 1;
+const emptyStats = () => ({
+    version: STATS_VERSION,
+    updatedAt: new Date(0).toISOString(),
+    logsForwarded: 0,
+    batchesSucceeded: 0,
+    batchesFailed: 0,
+});
+export function getStatsFilePath() {
+    return path.join(getConfigDir(), "stats.json");
+}
+export async function readStats() {
+    try {
+        const raw = await fs.readFile(getStatsFilePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== STATS_VERSION)
+            return emptyStats();
+        return {
+            ...emptyStats(),
+            ...parsed,
+            version: STATS_VERSION,
+        };
+    }
+    catch {
+        return emptyStats();
+    }
+}
+async function writeStatsAtomic(stats) {
+    const file = getStatsFilePath();
+    const dir = path.dirname(file);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(stats, null, 2), "utf8");
+    await fs.rename(tmp, file);
+}
+export async function recordSuccessfulBatch(logCount) {
+    try {
+        const cur = await readStats();
+        await writeStatsAtomic({
+            version: STATS_VERSION,
+            updatedAt: new Date().toISOString(),
+            logsForwarded: cur.logsForwarded + logCount,
+            batchesSucceeded: cur.batchesSucceeded + 1,
+            batchesFailed: cur.batchesFailed,
+            lastError: undefined,
+        });
+    }
+    catch {
+        // stats are best-effort; never break forwarding
+    }
+}
+export async function recordFailedBatch(message) {
+    try {
+        const cur = await readStats();
+        const trimmed = message.replace(/\s+/g, " ").slice(0, 500);
+        await writeStatsAtomic({
+            version: STATS_VERSION,
+            updatedAt: new Date().toISOString(),
+            logsForwarded: cur.logsForwarded,
+            batchesSucceeded: cur.batchesSucceeded,
+            batchesFailed: cur.batchesFailed + 1,
+            lastError: trimmed || "Unknown error",
+        });
+    }
+    catch {
+        // best-effort
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsoc/beacon",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Lightweight, background-running log forwarder (beacon) for AgentSOC",
   "type": "module",
   "bin": {