crbro-memory 2.10.0 → 2.11.0

package/dist/build-id.json

@@ -0,0 +1,10 @@
+{
+  "build": "2.11.0-facd12b9308f70d1",
+  "version": "2.11.0",
+  "hash": "facd12b9308f70d1d1a73893100f10af8aa28c0a8f26f486a3ac7a23afb8a9e3",
+  "files": 65,
+  "check": {
+    "file": "server.js",
+    "sha256": "c05fd945b738c1f2c91059251c12ba24f443a2b583b62068f5d4170d028d4d36"
+  }
+}

package/dist/cli/common.js

@@ -0,0 +1,211 @@
+"use strict";
+// ─── Shared pieces of the export / import / view / serve commands ──
+//
+// Small on purpose: argument parsing, path containment, tokens and the two
+// checks every local HTTP listener of this package makes (Host header and
+// bearer token). Nothing here reads or writes the brain.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_SECURITY_HEADERS = void 0;
+exports.parseArgs = parseArgs;
+exports.realpathNearest = realpathNearest;
+exports.isInside = isInside;
+exports.safeFileName = safeFileName;
+exports.randomToken = randomToken;
+exports.tokenMatches = tokenMatches;
+exports.bearerOf = bearerOf;
+exports.isLoopbackHost = isLoopbackHost;
+exports.loopbackHosts = loopbackHosts;
+exports.hostAllowed = hostAllowed;
+exports.waitForStop = waitForStop;
+exports.openBrowser = openBrowser;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+/**
+ * `--name value`, `--name=value` and bare `--flag`. Unknown flags are an
+ * error, never ignored: a typo in `--include-retired` must not export less
+ * than the user asked for and say nothing.
+ */
+function parseArgs(argv, spec) {
+    const flags = {};
+    const positionals = [];
+    const errors = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '-h') {
+            flags['help'] = true;
+            continue;
+        }
+        if (!a.startsWith('--')) {
+            positionals.push(a);
+            continue;
+        }
+        const eq = a.indexOf('=');
+        const name = eq === -1 ? a.slice(2) : a.slice(2, eq);
+        const kind = spec[name] ?? (name === 'help' ? 'boolean' : undefined);
+        if (!kind) {
+            errors.push(`unknown option --${name}`);
+            continue;
+        }
+        if (kind === 'boolean') {
+            if (eq !== -1)
+                errors.push(`--${name} takes no value`);
+            flags[name] = true;
+            continue;
+        }
+        let value = eq === -1 ? argv[i + 1] : a.slice(eq + 1);
+        if (eq === -1) {
+            if (value === undefined || value.startsWith('--')) {
+                errors.push(`--${name} needs a value`);
+                continue;
+            }
+            i++;
+        }
+        if (kind === 'number') {
+            const n = Number(value);
+            if (!/^\d+$/.test(value) || !Number.isSafeInteger(n)) {
+                errors.push(`--${name} must be a whole number`);
+                continue;
+            }
+            flags[name] = n;
+        }
+        else if (kind === 'list') {
+            const list = flags[name] ?? [];
+            list.push(value);
+            flags[name] = list;
+        }
+        else {
+            flags[name] = value;
+        }
+    }
+    return { flags, positionals, errors };
+}
+// ─── Paths ───────────────────────────────────────────────────────
+/** The real path of `p`, or of its nearest existing ancestor plus the rest. Follows links and junctions. */
+async function realpathNearest(p) {
+    let current = node_path_1.default.resolve(p);
+    const rest = [];
+    for (;;) {
+        try {
+            const real = await node_fs_1.promises.realpath(current);
+            return rest.length ? node_path_1.default.join(real, ...rest.reverse()) : real;
+        }
+        catch {
+            const parent = node_path_1.default.dirname(current);
+            if (parent === current)
+                return node_path_1.default.resolve(p);
+            rest.push(node_path_1.default.basename(current));
+            current = parent;
+        }
+    }
+}
+/** Is `child` the same folder as `parent`, or inside it? Case-insensitive where the file system is. */
+function isInside(child, parent) {
+    const norm = (s) => (process.platform === 'win32' || process.platform === 'darwin' ? s.toLowerCase() : s);
+    const rel = node_path_1.default.relative(norm(node_path_1.default.resolve(parent)), norm(node_path_1.default.resolve(child)));
+    return rel === '' || (!rel.startsWith('..') && !node_path_1.default.isAbsolute(rel));
+}
+/**
+ * A file name from free text (a domain, a neuron id): letters, digits, dot,
+ * dash and underscore only, never `.`/`..`, never empty, at most 120 chars.
+ * Everything a note is called goes through here, so no part of the brain can
+ * steer a write outside the export folder.
+ */
+function safeFileName(raw, fallback = 'untitled') {
+    let s = String(raw ?? '').normalize('NFKD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^A-Za-z0-9._-]+/g, '_').replace(/_+/g, '_').replace(/^[._]+/, '').slice(0, 120);
+    s = s.replace(/[. ]+$/, '');
+    if (!s || s === '.' || s === '..')
+        s = fallback;
+    // Windows reserved device names are not valid file names on any drive.
+    if (/^(con|prn|aux|nul|com\d|lpt\d)(\..*)?$/i.test(s))
+        s = `_${s}`;
+    return s;
+}
+// ─── Tokens and HTTP guards ──────────────────────────────────────
+/** 32 random bytes, hex: no character a shell, a URL or a header has to escape. */
+function randomToken() {
+    return (0, node_crypto_1.randomBytes)(32).toString('hex');
+}
+/**
+ * Constant-time comparison of a presented secret with the expected one.
+ * Both sides are hashed first so the lengths always match and the time does
+ * not depend on how many leading characters were right.
+ */
+function tokenMatches(presented, expected) {
+    if (typeof presented !== 'string' || presented.length === 0 || presented.length > 4096)
+        return false;
+    const a = (0, node_crypto_1.createHash)('sha256').update(presented, 'utf8').digest();
+    const b = (0, node_crypto_1.createHash)('sha256').update(expected, 'utf8').digest();
+    return (0, node_crypto_1.timingSafeEqual)(a, b);
+}
+/** The bearer value of an Authorization header, or null. */
+function bearerOf(header) {
+    if (typeof header !== 'string')
+        return null;
+    const m = /^Bearer[ ]+([^\s]+)\s*$/i.exec(header);
+    return m ? m[1] : null;
+}
+function isLoopbackHost(host) {
+    const h = host.trim().toLowerCase().replace(/^\[|\]$/g, '');
+    return h === 'localhost' || h === '::1' || /^127(\.\d{1,3}){3}$/.test(h);
+}
+/** The Host header values a loopback listener on `port` accepts. Anything else is a DNS-rebinding attempt or a mistake. */
+function loopbackHosts(port) {
+    return [`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`];
+}
+function hostAllowed(hostHeader, allowed) {
+    if (typeof hostHeader !== 'string' || !hostHeader)
+        return false;
+    const h = hostHeader.trim().toLowerCase();
+    for (const a of allowed)
+        if (a.toLowerCase() === h)
+            return true;
+    return false;
+}
+/** Headers every response of ours carries: nothing cached, nothing sniffed, nothing framed, no referrer. */
+exports.BASE_SECURITY_HEADERS = {
+    'X-Content-Type-Options': 'nosniff',
+    'Cache-Control': 'no-store',
+    'Referrer-Policy': 'no-referrer',
+    'X-Frame-Options': 'DENY',
+    'Cross-Origin-Resource-Policy': 'same-origin',
+};
+// ─── Lifetime ────────────────────────────────────────────────────
+/** Resolve on Ctrl+C, SIGTERM or the abort signal, then forget the handlers. */
+function waitForStop(signal) {
+    return new Promise(resolve => {
+        const stop = () => {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            signal?.removeEventListener('abort', stop);
+            resolve();
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+        if (signal?.aborted)
+            stop();
+        else
+            signal?.addEventListener('abort', stop);
+    });
+}
+// ─── Browser ─────────────────────────────────────────────────────
+/** Open a URL in the default browser. Best effort: the URL is printed anyway. */
+function openBrowser(url) {
+    try {
+        const opts = { detached: true, stdio: 'ignore', windowsHide: true };
+        const child = process.platform === 'win32'
+            ? (0, node_child_process_1.spawn)('rundll32', ['url.dll,FileProtocolHandler', url], opts)
+            : process.platform === 'darwin'
+                ? (0, node_child_process_1.spawn)('open', [url], opts)
+                : (0, node_child_process_1.spawn)('xdg-open', [url], opts);
+        child.on('error', () => undefined);
+        child.unref();
+    }
+    catch { /* printed URL is the fallback */ }
+}
+//# sourceMappingURL=common.js.map