@memnexus-ai/cli 1.7.232 → 1.7.234

package/dist/lib/content-input.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTENT_FILE_STDIN = exports.MAX_CONTENT_FILE_BYTES = exports.MAX_MEMORY_CONTENT_LENGTH = void 0;
+exports.readStreamBounded = readStreamBounded;
+exports.resolveContentInput = resolveContentInput;
+/**
+ * Shell-safe content input for `mx memories create` / `mx memories update`.
+ *
+ * Why this exists: agent-authored prose passed as `--content "..."` in a
+ * double-quoted shell argument has backticks and `$(...)` expanded by the shell
+ * BEFORE `mx` is invoked, so the stored memory silently contains command output
+ * instead of the author's text. The CLI never sees the original bytes, so it
+ * cannot detect or repair the damage. `--content-file <path>` gives callers an
+ * input path the shell never parses: the file (or stdin) is read verbatim.
+ *
+ * Guarantees:
+ *  - Byte-exact: the decoded UTF-8 content is used as-is. No trimming, no
+ *    newline normalization, no interpolation of any kind.
+ *  - Fail-loud: a missing, unreadable, empty, oversized, non-regular, or blank
+ *    path is a non-zero exit with the path named. Never a silent success, and
+ *    never a silent hang.
+ *  - Fail-early: the 50,000-character server cap is enforced before the network
+ *    call, so an oversized body reports a clear local error rather than a 413.
+ *
+ * Stdin is read through the stream API and completes only on the stream's `end`
+ * event, because a pipe delivers its data in as many writes as the producer
+ * chooses. An earlier revision read fd 0 in a synchronous loop and stopped on
+ * EAGAIN, which returned a prefix of the input as though it were the whole
+ * input whenever the producer paused between writes.
+ *
+ * Reads are bounded at every step. Neither the size check nor the read may be
+ * skipped by pointing the flag at something that is not a regular file: an
+ * earlier revision checked only `st_size`, which is 0 for FIFOs and character
+ * devices, so `--content-file <fifo>` blocked forever and `--content-file
+ * /dev/zero` allocated until the heap died. Both are now rejected before a
+ * single byte is read, and the read itself is chunk-bounded as a backstop
+ * against a file that grows after it is measured.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const errors_1 = require("./errors");
+/**
+ * Maximum memory content length, in JavaScript String.length units (UTF-16 code
+ * units) — NOT bytes. Mirrors MAX_NAMED_MEMORY_CONTENT_LENGTH in
+ * core-api/src/schemas/memory.schema.ts, which is enforced by Zod `.max()` on
+ * every server-side content write path. Enforced locally so an oversized file
+ * fails before the request instead of returning a 413. The server still
+ * enforces its own limit — this is a usability guard, not a trust boundary.
+ */
+exports.MAX_MEMORY_CONTENT_LENGTH = 50000;
+/**
+ * Byte ceiling on the file/stdin read. 50,000 characters is at most 200,000
+ * UTF-8 bytes, so 1 MB leaves generous headroom while bounding memory (CWE-400).
+ * Applied three ways: to the stat size of a regular file, to the running total
+ * of the chunked read, and to stdin. Mirrors BATCH_CREATE_MAX_LINE_BYTES.
+ */
+exports.MAX_CONTENT_FILE_BYTES = 1024 * 1024;
+/** Chunk size for the bounded read. */
+const READ_CHUNK_BYTES = 64 * 1024;
+/** Sentinel path meaning "read stdin". */
+exports.CONTENT_FILE_STDIN = '-';
+/**
+ * Read a whole REGULAR-FILE descriptor with a hard byte ceiling, in chunks.
+ *
+ * Only ever called on a descriptor already asserted to be a regular file, which
+ * is why a short read here means end-of-file and nothing else. The ceiling is
+ * enforced on the running total, so a file that grows after it was measured
+ * still cannot exceed it.
+ *
+ * No read error is swallowed. An earlier revision treated EAGAIN as
+ * end-of-input, which is only true on a blocking descriptor: on a non-blocking
+ * one it means "no bytes available right now, the writer has not closed", and
+ * returning at that point yields a prefix of the input as though it were all of
+ * it. Stdin — the descriptor that is actually non-blocking — no longer goes
+ * through this function at all; see readStreamBounded.
+ */
+function readFdBounded(fd, maxBytes, label) {
+    const chunks = [];
+    const buf = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+    let total = 0;
+    for (;;) {
+        let n;
+        try {
+            n = fs.readSync(fd, buf, 0, buf.length, null);
+        }
+        catch (err) {
+            throw (0, errors_1.validationError)(`${label}: read failed (${err?.code || err?.message}).`);
+        }
+        if (n === 0)
+            break;
+        total += n;
+        if (total > maxBytes) {
+            throw (0, errors_1.validationError)(`${label}: input exceeds the ${maxBytes}-byte limit. Nothing was sent.`);
+        }
+        chunks.push(Buffer.from(buf.subarray(0, n)));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * Read a readable stream to completion with a hard byte ceiling.
+ *
+ * This is how stdin is read. A pipe delivers its data in as many writes as the
+ * producer chooses — a script writing line by line, `jq`, `git log`, one `mx`
+ * piped into another — and the only correct end-of-input signal is the stream's
+ * own `end` event. A synchronous read loop over fd 0 cannot see that: fd 0 is
+ * non-blocking in the shipped binary (libuv attaches a Pipe handle with
+ * O_NONBLOCK as soon as anything touches `process.stdin`, which `chalk` does
+ * transitively), so a gap between two writes surfaces as EAGAIN and any
+ * treatment of EAGAIN as EOF truncates the input silently.
+ *
+ * Bytes are accumulated as Buffers and decoded once at the end, so a multi-byte
+ * UTF-8 sequence split across two chunks is not corrupted.
+ *
+ * A TTY returns '' immediately rather than waiting for input that is not
+ * coming: the caller reports that as the empty-content error, so
+ * `mx ... --content-file -` at an interactive prompt fails fast instead of
+ * hanging.
+ */
+function readStreamBounded(stream, maxBytes, label) {
+    if (stream.isTTY)
+        return Promise.resolve('');
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            fn();
+        };
+        stream.on('data', (chunk) => {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            total += buf.length;
+            if (total > maxBytes) {
+                settle(() => {
+                    // Stop draining rather than keep buffering a runaway producer.
+                    stream.destroy?.();
+                    reject((0, errors_1.validationError)(`${label}: input exceeds the ${maxBytes}-byte limit. Nothing was sent.`));
+                });
+                return;
+            }
+            chunks.push(buf);
+        });
+        // `end` is the ONLY success signal. Anything earlier is a partial read.
+        stream.on('end', () => settle(() => resolve(Buffer.concat(chunks).toString('utf8'))));
+        stream.on('error', (err) => settle(() => reject((0, errors_1.validationError)(`${label}: read failed (${err?.code || err?.message}).`))));
+    });
+}
+function readStdin() {
+    return readStreamBounded(process.stdin, exports.MAX_CONTENT_FILE_BYTES, '--content-file -');
+}
+/**
+ * Read the content a create/update should send.
+ *
+ * Returns `undefined` only when NEITHER flag was supplied (the caller decides
+ * whether that is an error, an interactive prompt, or a no-op update). A flag
+ * that is present but carries an empty value is an error, never a silent
+ * `undefined` — `--content-file "$BODY_FILE"` with the variable unset is
+ * exactly the shell accident this flag exists to defend against, and on
+ * `update` a silent `undefined` reports success while the body stays stale.
+ *
+ * Throws a CLIError — which `handleError` turns into exit 2 — for every failure
+ * mode below.
+ *
+ * The path is used only as a filesystem path: it is resolved with
+ * `path.resolve` and passed to `fs.openSync`. It is never interpolated into a
+ * shell command and no process is spawned, so a path containing shell
+ * metacharacters is inert. Reads run with the invoking user's privileges and no
+ * path is privileged by the CLI, so this grants no read the caller did not
+ * already have; symlinks are followed deliberately (pointing at a symlink to
+ * your own note is a legitimate use, and refusing them closes nothing, since
+ * the caller could read the target directly).
+ */
+async function resolveContentInput(options, deps = {}) {
+    const hasContent = typeof options.content === 'string';
+    // Presence, not usability: an empty --content-file value is a present flag
+    // with a bad value and must be reported, not treated as absent.
+    const hasFile = typeof options.contentFile === 'string';
+    if (hasContent && hasFile) {
+        throw (0, errors_1.validationError)('Cannot use --content and --content-file together. Pass exactly one.\n' +
+            '  --content <text>       inline text (the shell interprets backticks and $(...) in double quotes)\n' +
+            '  --content-file <path>  read the content verbatim from a file, or "-" for stdin');
+    }
+    if (hasFile && options.interactive) {
+        throw (0, errors_1.validationError)('Cannot use --content-file with --interactive. Interactive mode would print the ' +
+            "file's contents to the terminal as the prompt default, which defeats the point of " +
+            'passing content by file. Drop --interactive, or use --content for text you are ' +
+            'willing to see echoed.');
+    }
+    if (!hasFile) {
+        if (hasContent)
+            assertWithinContentLimit(options.content, '--content');
+        return options.content;
+    }
+    const rawPath = options.contentFile;
+    if (rawPath.trim().length === 0) {
+        throw (0, errors_1.validationError)('--content-file was given an empty path. If this came from a shell variable ' +
+            '(--content-file "$BODY_FILE"), the variable is unset or misspelled. ' +
+            'Nothing was read and nothing was sent.');
+    }
+    const label = rawPath === exports.CONTENT_FILE_STDIN ? '--content-file -' : `--content-file ${rawPath}`;
+    const content = rawPath === exports.CONTENT_FILE_STDIN
+        ? await (deps.readStdin ?? readStdin)()
+        : readContentFile(rawPath);
+    if (content.trim().length === 0) {
+        throw (0, errors_1.validationError)(`${label}: file is empty (no non-whitespace content). Refusing to create an empty memory.`);
+    }
+    assertWithinContentLimit(content, label);
+    return content;
+}
+function readContentFile(rawPath) {
+    const resolved = path.resolve(rawPath);
+    const label = `--content-file ${rawPath}`;
+    // Pre-open classification. Opening a FIFO read-only blocks until a writer
+    // appears, so the kind of the path must be known BEFORE the open. O_NONBLOCK
+    // below makes the open safe even if the path is swapped after this check.
+    let preStat;
+    try {
+        preStat = fs.statSync(resolved);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            throw (0, errors_1.validationError)(`${label}: file not found (resolved to ${resolved}).`);
+        }
+        throw (0, errors_1.validationError)(`${label}: cannot stat file (${err?.code || err?.message}).`);
+    }
+    assertRegularFile(preStat, label, resolved);
+    // O_NONBLOCK: on a FIFO or a device this returns immediately instead of
+    // blocking, closing the window where the path is replaced between the stat
+    // above and this open. It has no effect on a regular file.
+    const nonBlock = fs.constants.O_NONBLOCK ?? 0;
+    let fd;
+    try {
+        fd = fs.openSync(resolved, fs.constants.O_RDONLY | nonBlock);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            throw (0, errors_1.validationError)(`${label}: file not found (resolved to ${resolved}).`);
+        }
+        throw (0, errors_1.validationError)(`${label}: cannot open file (${err?.code || err?.message}).`);
+    }
+    try {
+        // Re-assert on the descriptor actually opened, not on the path. This is
+        // what closes the time-of-check/time-of-use gap: every check from here on
+        // describes the same inode the bytes come from.
+        const stat = fs.fstatSync(fd);
+        assertRegularFile(stat, label, resolved);
+        if (stat.size > exports.MAX_CONTENT_FILE_BYTES) {
+            throw (0, errors_1.validationError)(`${label}: file is ${stat.size} bytes, over the ${exports.MAX_CONTENT_FILE_BYTES}-byte limit.`);
+        }
+        return readFdBounded(fd, exports.MAX_CONTENT_FILE_BYTES, label);
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            // Nothing useful to do if the descriptor is already gone.
+        }
+    }
+}
+/**
+ * Positive assertion that the target is a regular file.
+ *
+ * `st_size` is 0 for FIFOs, sockets, and character devices, so a size-only
+ * check is not a weak bound on those — it is no bound. Note that procfs entries
+ * ARE regular files reporting size 0, so this does not make them unreadable;
+ * they are still bounded by the chunked read.
+ */
+function assertRegularFile(stat, label, resolved) {
+    if (stat.isDirectory()) {
+        throw (0, errors_1.validationError)(`${label}: path is a directory, not a file.`);
+    }
+    if (!stat.isFile()) {
+        throw (0, errors_1.validationError)(`${label}: not a regular file (resolved to ${resolved}). ` +
+            'Named pipes, sockets and devices are refused because they have no bounded size — ' +
+            'reading one would hang or exhaust memory. Write the content to a real file first.');
+    }
+}
+function assertWithinContentLimit(content, label) {
+    if (content.length > exports.MAX_MEMORY_CONTENT_LENGTH) {
+        throw (0, errors_1.validationError)(`${label}: content is ${content.length} characters, over the ${exports.MAX_MEMORY_CONTENT_LENGTH}-character server limit. ` +
+            'Split it into multiple memories, or shorten it. Nothing was sent.');
+    }
+}
+//# sourceMappingURL=content-input.js.map

package/dist/lib/content-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-input.js","sourceRoot":"","sources":["../../src/lib/content-input.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memnexus-ai/cli",
-  "version": "1.7.232",
+  "version": "1.7.234",
   "description": "Command-line interface for MemNexus Core API",
   "main": "dist/index.js",
   "bin": {
@@ -34,7 +34,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@memnexus-ai/typescript-sdk": "^1.74.3",
+    "@memnexus-ai/typescript-sdk": "^1.75.3",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "axios": "^1.13.6",
     "chalk": "^5.3.0",