@ours.network/notifications 0.1.1

package/dist/cli.js

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+// ours-notify — CLI + lifecycle for the ours.network notifications daemon.
+// Mirrors ours-mcp / ours-tg-connector: pidfile-based start/stop/restart/status,
+// a foreground `serve`, and install-service (systemd user unit + linger on Linux,
+// launchd on macOS) that bakes the resolved config into the unit. The daemon's
+// protocol logic (WebPush egress, scoped-token validation, registrations,
+// discovery) is unchanged — this only wraps it in a proper service skeleton.
+//
+//   ours-notify start | stop | restart | status | serve
+//   ours-notify install-service | uninstall-service | version | help
+import * as fs from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { connect } from 'node:net';
+import { createInterface } from 'node:readline';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir, userInfo } from 'node:os';
+import { resolveConfig, loadConfig } from './config.js';
+import { provision } from './provision.js';
+// NOTE: ./daemon.js (which loads the native ADAPT SDK) is imported lazily inside
+// cmdServe so help/version/status/stop stay light and don't spin up the SDK.
+const DEFAULT_DISCOVERY_PORT = 8890;
+const SELF = fileURLToPath(import.meta.url);
+const out = (...p) => process.stdout.write(`${p.join(' ')}\n`);
+const err = (...p) => process.stderr.write(`${p.join(' ')}\n`);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function cliVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(join(dirname(SELF), '..', 'package.json'), 'utf8'));
+        return String(pkg.version ?? '0.0.0-dev');
+    }
+    catch {
+        return '0.0.0-dev';
+    }
+}
+// Resolved once — the port the CLI operates on (config port, else product default).
+const R0 = resolveConfig();
+const STATE_DIR = R0.stateDir;
+const PORT = R0.discoveryPort ?? DEFAULT_DISCOVERY_PORT;
+const PID_PATH = join(STATE_DIR, 'daemon.pid');
+const LOG_PATH = join(STATE_DIR, 'daemon.log');
+function readPid() {
+    try {
+        const n = parseInt(fs.readFileSync(PID_PATH, 'utf8').trim(), 10);
+        return Number.isFinite(n) ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runningPid() {
+    const pid = readPid();
+    if (pid && isAlive(pid))
+        return pid;
+    if (pid) {
+        try {
+            fs.rmSync(PID_PATH, { force: true });
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+function portOpen(port, timeoutMs = 1000) {
+    return new Promise((res) => {
+        const sock = connect({ host: '127.0.0.1', port });
+        const done = (ok) => { sock.destroy(); res(ok); };
+        sock.setTimeout(timeoutMs);
+        sock.once('connect', () => done(true));
+        sock.once('timeout', () => done(false));
+        sock.once('error', () => done(false));
+    });
+}
+async function waitForPort(port, totalMs = 30_000) {
+    const deadline = Date.now() + totalMs;
+    while (Date.now() < deadline) {
+        if (await portOpen(port))
+            return true;
+        await sleep(400);
+    }
+    return false;
+}
+async function fetchDiscovery() {
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 1500);
+        const resp = await fetch(`http://127.0.0.1:${PORT}/v1/discovery`, { signal: ctrl.signal });
+        clearTimeout(t);
+        if (resp.ok)
+            return (await resp.json());
+    }
+    catch { /* unreachable */ }
+    return null;
+}
+// ---- serve (foreground) -----------------------------------------------------
+async function cmdServe() {
+    const r = resolveConfig();
+    if (!r.brokerUrl) {
+        err('BROKER_URL is required (env BROKER_URL or config.json "brokerUrl").');
+        process.exit(1);
+    }
+    provision(r); // mkdir state dir + generate VAPID if absent (identity.key self-provisions in startDaemon)
+    if (r.discoveryPort === undefined && !process.env.DISCOVERY_PORT) {
+        process.env.DISCOVERY_PORT = String(DEFAULT_DISCOVERY_PORT); // product default
+    }
+    const cfg = loadConfig();
+    const { startDaemon } = await import('./daemon.js');
+    const daemon = await startDaemon(cfg);
+    const emit = (obj) => process.stdout.write(JSON.stringify(obj) + '\n');
+    emit({ event: 'ready', cid: daemon.cid, version: daemon.version, port: cfg.discoveryPort, stateDir: cfg.stateDir });
+    daemon.onEvent((e) => emit(e));
+    // Optional JSON-lines control on stdin (handy for `serve` in the foreground).
+    const rl = createInterface({ input: process.stdin });
+    rl.on('line', (line) => {
+        void (async () => {
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            try {
+                if (msg.cmd === 'invite')
+                    emit({ reply: await daemon.invite(msg.name ?? '') });
+                else if (msg.cmd === 'contacts')
+                    emit({ reply: daemon.contacts() });
+                else if (msg.cmd === 'status')
+                    emit({ reply: { cid: daemon.cid, version: daemon.version } });
+                else if (msg.cmd === 'notifications')
+                    emit({ reply: daemon.logStore.list() });
+                else
+                    emit({ reply: { error: `unknown cmd ${msg.cmd}` } });
+            }
+            catch (e) {
+                emit({ reply: { error: String(e) } });
+            }
+        })();
+    });
+    const shutdown = () => { void daemon.stop().then(() => process.exit(0)); };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+}
+// ---- start / stop / restart / status ---------------------------------------
+async function cmdStart() {
+    const existing = runningPid();
+    if (existing) {
+        out(`ours-notify is already running (pid ${existing}, port ${PORT}).`);
+        return;
+    }
+    const r = resolveConfig();
+    if (!r.brokerUrl) {
+        err('BROKER_URL is required (env BROKER_URL or config.json "brokerUrl"), e.g. ws://127.0.0.1:9000');
+        process.exit(1);
+    }
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const logFd = fs.openSync(LOG_PATH, 'a');
+    const child = spawn(process.execPath, [SELF, 'serve'], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: {
+            ...process.env,
+            BROKER_URL: r.brokerUrl,
+            STATE_DIR,
+            DISCOVERY_PORT: String(PORT),
+            DISCOVERY_HOST: r.discoveryHost,
+        },
+    });
+    child.unref();
+    if (!child.pid) {
+        err('failed to spawn the daemon.');
+        process.exit(1);
+    }
+    fs.writeFileSync(PID_PATH, String(child.pid));
+    out(`starting ours-notify (pid ${child.pid})…`);
+    if (await waitForPort(PORT)) {
+        const d = await fetchDiscovery();
+        out(`ours-notify is up on http://${r.discoveryHost}:${PORT}/v1/discovery`);
+        if (d?.service_cid)
+            out(`  cid:    ${d.service_cid}`);
+        out(`  broker: ${r.brokerUrl}`);
+        out(`  state:  ${STATE_DIR}`);
+        out(`  logs:   ${LOG_PATH}`);
+    }
+    else {
+        err(`daemon started (pid ${child.pid}) but port ${PORT} did not open within 30s — check ${LOG_PATH}.`);
+        process.exit(1);
+    }
+}
+async function cmdStop() {
+    const pid = runningPid();
+    if (!pid) {
+        out('ours-notify is not running.');
+        return;
+    }
+    out(`stopping ours-notify (pid ${pid})…`);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch (e) {
+        err(`failed to signal pid ${pid}: ${String(e)}`);
+    }
+    for (let i = 0; i < 25 && isAlive(pid); i++)
+        await sleep(200);
+    if (isAlive(pid)) {
+        err(`pid ${pid} did not exit; sending SIGKILL.`);
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch { /* ignore */ }
+    }
+    try {
+        fs.rmSync(PID_PATH, { force: true });
+    }
+    catch { /* ignore */ }
+    out('stopped.');
+}
+async function cmdStatus() {
+    const pid = runningPid();
+    const reachable = await portOpen(PORT);
+    if (pid || reachable) {
+        out(pid ? `ours-notify: running (pid ${pid})` : 'ours-notify: running (no pidfile — external launcher or stale process)');
+        out(`  url:    http://127.0.0.1:${PORT}/v1/discovery${reachable ? ' (reachable)' : ' (not reachable yet)'}`);
+        const d = reachable ? await fetchDiscovery() : null;
+        if (d?.service_cid)
+            out(`  cid:    ${d.service_cid}`);
+        if (d?.broker_url)
+            out(`  broker: ${d.broker_url}`);
+        if (d)
+            out(`  vapid:  ${d.vapid_public_key ? 'advertised' : 'absent'}`);
+        out(`  state:  ${STATE_DIR}`);
+        out(`  cli:    v${cliVersion()}`);
+        return;
+    }
+    out('ours-notify: stopped');
+    out(`  state:  ${STATE_DIR}`);
+    out(`  cli:    v${cliVersion()}`);
+}
+// ---- install-service --------------------------------------------------------
+const SYSTEMD_UNIT = process.env.OURS_NOTIFY_SERVICE_NAME ?? 'ours-notify.service';
+const LAUNCHD_LABEL = 'solutions.adaptframework.ours-notify';
+function systemdUnitPath() { return join(homedir(), '.config', 'systemd', 'user', SYSTEMD_UNIT); }
+function launchdPlistPath() { return join(homedir(), 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`); }
+function runCmd(cmd, args) { return spawnSync(cmd, args, { stdio: 'inherit' }).status === 0; }
+// Exported so install-service can be validated (rendered + systemd-analyze verify)
+// without enabling a boot unit that competes with the running fleet.
+export function renderSystemdUnit() {
+    const r = resolveConfig();
+    const port = r.discoveryPort ?? DEFAULT_DISCOVERY_PORT;
+    return `[Unit]
+Description=ours.network notifications daemon (WebPush + a2a_notifications over ADAPT)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${SELF} serve
+Environment=STATE_DIR=${STATE_DIR}
+Environment=BROKER_URL=${r.brokerUrl ?? ''}
+Environment=DISCOVERY_PORT=${port}
+Environment=DISCOVERY_HOST=${r.discoveryHost}
+Environment=VAPID_SUBJECT=${r.vapidSubject}
+Restart=on-failure
+RestartSec=2
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function renderLaunchdPlist() {
+    const r = resolveConfig();
+    const port = r.discoveryPort ?? DEFAULT_DISCOVERY_PORT;
+    return `<?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>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${SELF}</string>
+    <string>serve</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>STATE_DIR</key><string>${STATE_DIR}</string>
+    <key>BROKER_URL</key><string>${r.brokerUrl ?? ''}</string>
+    <key>DISCOVERY_PORT</key><string>${port}</string>
+    <key>DISCOVERY_HOST</key><string>${r.discoveryHost}</string>
+    <key>VAPID_SUBJECT</key><string>${r.vapidSubject}</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key><string>${LOG_PATH}</string>
+</dict>
+</plist>
+`;
+}
+function installSystemd() {
+    const r = resolveConfig();
+    if (!r.brokerUrl) {
+        err('BROKER_URL is required to install the service (it is baked into the unit).');
+        process.exit(1);
+    }
+    const unitPath = systemdUnitPath();
+    fs.mkdirSync(dirname(unitPath), { recursive: true });
+    fs.writeFileSync(unitPath, renderSystemdUnit());
+    out(`wrote ${unitPath}`);
+    runCmd('systemctl', ['--user', 'daemon-reload']);
+    if (!runCmd('systemctl', ['--user', 'enable', '--now', SYSTEMD_UNIT])) {
+        err('failed to enable/start the service via systemctl --user.');
+        process.exit(1);
+    }
+    if (!runCmd('loginctl', ['enable-linger', userInfo().username])) {
+        err(`warning: could not enable linger — run manually: loginctl enable-linger ${userInfo().username}`);
+    }
+    out('');
+    out('ours-notify installed as a systemd user service and started.');
+    out(`  status:  systemctl --user status ${SYSTEMD_UNIT}`);
+    out(`  logs:    journalctl --user -u ${SYSTEMD_UNIT} -f`);
+    out('  remove:  ours-notify uninstall-service');
+}
+function uninstallSystemd() {
+    runCmd('systemctl', ['--user', 'disable', '--now', SYSTEMD_UNIT]);
+    const unitPath = systemdUnitPath();
+    try {
+        fs.rmSync(unitPath, { force: true });
+        out(`removed ${unitPath}`);
+    }
+    catch (e) {
+        err(`failed to remove ${unitPath}: ${String(e)}`);
+    }
+    runCmd('systemctl', ['--user', 'daemon-reload']);
+    out('ours-notify service uninstalled.');
+}
+function installLaunchd() {
+    const plistPath = launchdPlistPath();
+    fs.mkdirSync(dirname(plistPath), { recursive: true });
+    fs.writeFileSync(plistPath, renderLaunchdPlist());
+    out(`wrote ${plistPath}`);
+    const domain = `gui/${process.getuid()}`;
+    spawnSync('launchctl', ['bootout', domain, plistPath], { stdio: 'ignore' });
+    if (!runCmd('launchctl', ['bootstrap', domain, plistPath])) {
+        err('failed to load the launchd agent.');
+        process.exit(1);
+    }
+    out('');
+    out('ours-notify installed as a launchd agent and started.');
+    out('  remove:  ours-notify uninstall-service');
+}
+function uninstallLaunchd() {
+    const plistPath = launchdPlistPath();
+    const domain = `gui/${process.getuid()}`;
+    spawnSync('launchctl', ['bootout', domain, plistPath], { stdio: 'ignore' });
+    try {
+        fs.rmSync(plistPath, { force: true });
+        out(`removed ${plistPath}`);
+    }
+    catch (e) {
+        err(`failed to remove ${plistPath}: ${String(e)}`);
+    }
+    out('ours-notify service uninstalled.');
+}
+async function cmdInstallService() {
+    await cmdStop();
+    if (process.platform === 'linux')
+        return installSystemd();
+    if (process.platform === 'darwin')
+        return installLaunchd();
+    err(`install-service: unsupported platform "${process.platform}" (only linux/systemd and macOS/launchd).`);
+    process.exit(1);
+}
+function cmdUninstallService() {
+    if (process.platform === 'linux')
+        return uninstallSystemd();
+    if (process.platform === 'darwin')
+        return uninstallLaunchd();
+    err(`uninstall-service: unsupported platform "${process.platform}".`);
+    process.exit(1);
+}
+function usage() {
+    out('ours-notify — ours.network notifications daemon');
+    out('');
+    out('Usage: ours-notify <command>');
+    out('  start              start the daemon in the background');
+    out('  stop               stop the running daemon');
+    out('  restart            stop then start');
+    out('  status             show running state, port, cid, state dir, version');
+    out('  serve              run in the foreground (used by start; handy for debugging)');
+    out('  install-service    install + start a boot-persistent service (systemd/launchd)');
+    out('  uninstall-service  stop + remove that service');
+    out('  version            print the CLI version');
+    out('');
+    out('Config precedence (per field): env > config.json > default.');
+    out('  STATE_DIR (~/.ours-notifications) · BROKER_URL (required) · DISCOVERY_PORT (8890)');
+    out('  DISCOVERY_HOST (127.0.0.1) · VAPID_SUBJECT · config.json at $OURS_NOTIFY_CONFIG');
+    out('VAPID keys + identity self-provision into the state dir on first start.');
+}
+async function main() {
+    const cmd = process.argv[2];
+    switch (cmd) {
+        case 'serve': return cmdServe();
+        case 'start': return cmdStart();
+        case 'stop': return cmdStop();
+        case 'restart':
+            await cmdStop();
+            return cmdStart();
+        case 'status': return cmdStatus();
+        case 'install-service': return cmdInstallService();
+        case 'uninstall-service': return cmdUninstallService();
+        case 'version':
+            out(`ours-notify v${cliVersion()}`);
+            return;
+        case undefined:
+        case 'help':
+        case '--help':
+        case '-h': return usage();
+        default:
+            err(`unknown command: ${cmd}`);
+            usage();
+            process.exit(1);
+    }
+}
+// Run only as a CLI entrypoint (not when imported by tests). Compare via realpath
+// so the npm-installed `ours-notify` bin SYMLINK (argv[1]) still matches this
+// module's resolved path (import.meta.url) — a plain path compare would not.
+function invokedAsMain() {
+    try {
+        return !!process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(SELF);
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedAsMain()) {
+    main().catch((e) => { err(String(e?.stack ?? e)); process.exit(1); });
+}

package/dist/config.js

@@ -0,0 +1,104 @@
+// Daemon configuration. Portable and not host-bound: every field resolves by
+// precedence env > config.json > built-in default, so the same build runs as
+// the public instance or any self-hosted one (WebPush needs no vendor creds).
+//
+// config.json lives at $OURS_NOTIFY_CONFIG, else <HOME>/.ours-notifications/
+// config.json (a fixed home path, independent of a custom STATE_DIR — mirrors
+// ours-mcp). STATE_DIR defaults to <HOME>/.ours-notifications. VAPID keys are
+// read from <STATE_DIR>/vapid.{public,private} by default and are
+// self-provisioned on first boot (see provision.ts); inline VAPID_* env still
+// wins. DISCOVERY_PORT has no config-layer default — the CLI supplies the 8890
+// product default so running `dist/daemon.js` directly (and the test suite)
+// never binds a port unless asked.
+import * as fs from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+function homeBase(env) {
+    return env.HOME ?? env.USERPROFILE ?? homedir();
+}
+export function defaultStateDir(env = process.env) {
+    return join(homeBase(env), '.ours-notifications');
+}
+function configFilePath(env) {
+    return env.OURS_NOTIFY_CONFIG ?? join(homeBase(env), '.ours-notifications', 'config.json');
+}
+function readConfigFile(env) {
+    try {
+        const raw = fs.readFileSync(configFilePath(env), 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {}; // missing or invalid config.json → no overrides
+    }
+}
+function parsePort(raw, source) {
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${source} must be an integer in 1..65535, got: ${raw}`);
+    }
+    return port;
+}
+// Resolve every field by env > config.json > default. Never throws on VAPID
+// (files may not exist yet — provisioning creates them). Broker is left
+// undefined when unset; loadConfig enforces it.
+export function resolveConfig(env = process.env) {
+    const file = readConfigFile(env);
+    const pick = (envKey, fileKey, def) => env[envKey] ?? (file[fileKey] != null ? String(file[fileKey]) : undefined) ?? def;
+    const flag = (envKey, fileKey) => env[envKey] === '1' || file[fileKey] === true || file[fileKey] === '1';
+    const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+    const stateDir = resolve(pick('STATE_DIR', 'stateDir', defaultStateDir(env)));
+    const unitDir = resolve(pick('UNIT_DIR', 'unitDir', join(repoRoot, 'mufl_code')));
+    const vapidPublicFile = resolve(pick('VAPID_PUBLIC_KEY_FILE', 'vapidPublicFile', join(stateDir, 'vapid.public')));
+    const vapidPrivateFile = resolve(pick('VAPID_PRIVATE_KEY_FILE', 'vapidPrivateFile', join(stateDir, 'vapid.private')));
+    return {
+        brokerUrl: pick('BROKER_URL', 'brokerUrl'),
+        stateDir,
+        unitDir,
+        vapidPublicFile,
+        vapidPrivateFile,
+        vapidSubject: pick('VAPID_SUBJECT', 'vapidSubject', 'mailto:ops@ours.network'),
+        pushDisabled: flag('PUSH_DISABLED', 'pushDisabled'),
+        pushTlsInsecure: flag('PUSH_TLS_INSECURE', 'pushTlsInsecure'),
+        discoveryPort: parsePort(env.DISCOVERY_PORT ?? file.discoveryPort, 'DISCOVERY_PORT'),
+        discoveryHost: pick('DISCOVERY_HOST', 'discoveryHost', '127.0.0.1'),
+    };
+}
+// Full config with VAPID key CONTENTS. Inline VAPID_PUBLIC_KEY/PRIVATE_KEY env
+// wins over the files. Throws if the broker is unset or VAPID is still missing
+// (provisioning should have created it — run `ours-notify start`).
+export function loadConfig(env = process.env) {
+    const r = resolveConfig(env);
+    if (!r.brokerUrl) {
+        throw new Error('BROKER_URL is required (env BROKER_URL or config.json "brokerUrl"), e.g. ws://127.0.0.1:9000');
+    }
+    const readFileTrim = (p) => {
+        try {
+            return fs.readFileSync(p, 'utf8').trim();
+        }
+        catch {
+            return '';
+        }
+    };
+    const vapidPublicKey = (env.VAPID_PUBLIC_KEY?.trim()) || readFileTrim(r.vapidPublicFile);
+    const vapidPrivateKey = (env.VAPID_PRIVATE_KEY?.trim()) || readFileTrim(r.vapidPrivateFile);
+    if (!vapidPublicKey || !vapidPrivateKey) {
+        throw new Error(`VAPID keys missing under ${r.stateDir} — run \`ours-notify start\` (auto-provisions) ` +
+            `or generate them with scripts/gen-vapid.mjs`);
+    }
+    return {
+        brokerUrl: r.brokerUrl,
+        stateDir: r.stateDir,
+        unitDir: r.unitDir,
+        vapidPublicKey,
+        vapidPrivateKey,
+        vapidSubject: r.vapidSubject,
+        pushDisabled: r.pushDisabled,
+        pushTlsInsecure: r.pushTlsInsecure,
+        discoveryPort: r.discoveryPort,
+        discoveryHost: r.discoveryHost,
+    };
+}