mcdev 9.0.2 → 10.0.0

package/lib/util/sessionStore.js

@@ -0,0 +1,219 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+let sessionsPath;
+
+/**
+ * Resolve the conf-compatible session file path only when storage is first used.
+ *
+ * @returns {string} session file path
+ */
+function getSessionsPath() {
+    if (sessionsPath) {
+        return sessionsPath;
+    }
+
+    let configRoot;
+    if (process.platform === 'win32') {
+        configRoot =
+            process.env.APPDATA ||
+            path.join(process.env.USERPROFILE || os.homedir(), 'AppData', 'Roaming');
+        sessionsPath = path.join(configRoot, 'mcdev-nodejs', 'Config', 'sessions.json');
+    } else if (process.platform === 'darwin') {
+        sessionsPath = path.join(
+            os.homedir(),
+            'Library',
+            'Preferences',
+            'mcdev-nodejs',
+            'sessions.json'
+        );
+    } else {
+        configRoot = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        sessionsPath = path.join(configRoot, 'mcdev-nodejs', 'sessions.json');
+    }
+    return sessionsPath;
+}
+
+/**
+ * Reject filesystem objects that could redirect or replace the expected store location.
+ *
+ * @param {string} target path to inspect
+ * @param {'directory'|'file'} expectedType expected filesystem object type
+ * @returns {void}
+ */
+function validateExistingPath(target, expectedType) {
+    let stats;
+    try {
+        stats = fs.lstatSync(target);
+    } catch (ex) {
+        if (/** @type {NodeJS.ErrnoException} */ (ex).code === 'ENOENT') {
+            return;
+        }
+        throw ex;
+    }
+
+    if (stats.isSymbolicLink()) {
+        throw new Error(`Refusing session store link or reparse point: ${target}`);
+    }
+    if (expectedType === 'directory' ? !stats.isDirectory() : !stats.isFile()) {
+        throw new Error(`Unexpected session store ${expectedType} path: ${target}`);
+    }
+}
+
+/**
+ * Reject links and non-directories in every existing parent component.
+ *
+ * @param {string} directory directory path
+ * @returns {void}
+ */
+function validateDirectoryChain(directory) {
+    const resolved = path.resolve(directory);
+    const root = path.parse(resolved).root;
+    let current = root;
+    for (const segment of path.relative(root, resolved).split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        validateExistingPath(current, 'directory');
+    }
+}
+
+/**
+ * Create and validate the destination directory without traversing a link at the managed levels.
+ *
+ * @param {string} filePath session file path
+ * @returns {void}
+ */
+function ensureStoreDirectory(filePath) {
+    const projectDirectory = path.dirname(filePath);
+    const configDirectory = path.dirname(projectDirectory);
+    validateDirectoryChain(configDirectory);
+    fs.mkdirSync(configDirectory, { recursive: true, mode: 0o700 });
+    validateDirectoryChain(configDirectory);
+
+    const relativeProject = path.relative(configDirectory, projectDirectory);
+    if (!relativeProject || relativeProject.startsWith('..') || path.isAbsolute(relativeProject)) {
+        throw new Error(`Refusing session store parent traversal: ${projectDirectory}`);
+    }
+    validateExistingPath(projectDirectory, 'directory');
+    try {
+        fs.mkdirSync(projectDirectory, { mode: 0o700 });
+    } catch (ex) {
+        if (/** @type {NodeJS.ErrnoException} */ (ex).code !== 'EEXIST') {
+            throw ex;
+        }
+    }
+    validateExistingPath(projectDirectory, 'directory');
+    if (process.platform !== 'win32') {
+        fs.chmodSync(projectDirectory, 0o700);
+    }
+}
+
+/**
+ * Read the complete top-level session object, recovering invalid content as empty state.
+ *
+ * @returns {Record<string, unknown>} stored sessions
+ */
+function readSessions() {
+    const filePath = getSessionsPath();
+    validateExistingPath(filePath, 'file');
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    } catch (ex) {
+        if (['ENOENT', 'EISDIR'].includes(/** @type {NodeJS.ErrnoException} */ (ex).code || '')) {
+            return {};
+        }
+        if (ex instanceof SyntaxError) {
+            return {};
+        }
+        throw ex;
+    }
+}
+
+/**
+ * Atomically replace the session file with a fully synchronized JSON object.
+ *
+ * @param {Record<string, unknown>} sessions complete session object
+ * @returns {void}
+ */
+function writeSessions(sessions) {
+    const filePath = getSessionsPath();
+    ensureStoreDirectory(filePath);
+    validateExistingPath(filePath, 'file');
+    const directory = path.dirname(filePath);
+    const temporaryPath = path.join(
+        directory,
+        `.sessions.json.${process.pid}.${crypto.randomBytes(12).toString('hex')}.tmp`
+    );
+    let descriptor;
+    try {
+        descriptor = fs.openSync(temporaryPath, 'wx', 0o600);
+        fs.writeFileSync(descriptor, `${JSON.stringify(sessions, null, 2)}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        if (process.platform !== 'win32') {
+            fs.chmodSync(temporaryPath, 0o600);
+        }
+        fs.renameSync(temporaryPath, filePath);
+        if (process.platform !== 'win32') {
+            const directoryDescriptor = fs.openSync(directory, 'r');
+            try {
+                fs.fsyncSync(directoryDescriptor);
+            } finally {
+                fs.closeSync(directoryDescriptor);
+            }
+        }
+    } catch (ex) {
+        if (descriptor !== undefined) {
+            fs.closeSync(descriptor);
+        }
+        try {
+            fs.unlinkSync(temporaryPath);
+        } catch (ex_) {
+            if (/** @type {NodeJS.ErrnoException} */ (ex_).code !== 'ENOENT') {
+                throw new AggregateError([ex_, ex], 'Session write and cleanup failed', {
+                    cause: ex_,
+                });
+            }
+        }
+        throw ex;
+    }
+}
+
+const sessionStore = {
+    /**
+     * Read one session value.
+     *
+     * @param {string} key session key
+     * @returns {unknown} stored value
+     */
+    get(key) {
+        return readSessions()[key];
+    },
+
+    /**
+     * Persist one session value while preserving unrelated keys.
+     *
+     * @param {string} key session key
+     * @param {unknown} value session value
+     * @returns {void}
+     */
+    set(key, value) {
+        const sessions = readSessions();
+        sessions[key] = value;
+        writeSessions(sessions);
+    },
+
+    /**
+     * Remove all stored sessions.
+     *
+     * @returns {void}
+     */
+    clear() {
+        writeSessions({});
+    },
+};
+
+export default sessionStore;

package/lib/util/topological-sort.js

@@ -0,0 +1,114 @@
+'use strict';
+
+/**
+ * Minimal stable topological sort replacing the `toposort` package.
+ *
+ * The supported graph contract is an array of directed `[from, to]` edges. The returned array
+ * contains every distinct endpoint once and places each `from` value before its corresponding
+ * `to` value. Node discovery order is preserved for unrelated nodes, repeated edges are ignored,
+ * and cycles throw the same error shape used by the former dependency. Call sites remain
+ * responsible for removing sentinel endpoints such as `undefined`.
+ *
+ * This module intentionally omits the package's separate API for sorting an explicit node list,
+ * including its unknown-node validation, because mcdev only sorts nodes discovered from edges.
+ */
+
+/**
+ * Sort directed graph endpoints while retaining stable order for unrelated nodes.
+ *
+ * @template T
+ * @param {T[][]} edges directed `[dependency, dependent]` pairs
+ * @returns {T[]} each distinct endpoint in dependency-first order
+ * @throws {Error} when the graph contains a cyclic dependency
+ */
+export function topologicalSort(edges) {
+    const nodes = uniqueNodes(edges);
+    const sorted = Array.from({ length: nodes.length });
+    const visited = new Set();
+    const outgoingEdges = makeOutgoingEdges(edges);
+    let cursor = nodes.length;
+
+    /**
+     * Visit one node and its dependents in reverse insertion order to preserve package parity.
+     *
+     * @param {T} node graph endpoint to visit
+     * @param {Set.<T>} predecessors nodes in the current traversal path
+     * @returns {void}
+     * @throws {Error} when the current traversal reaches a predecessor again
+     */
+    function visit(node, predecessors) {
+        if (predecessors.has(node)) {
+            throw new Error(`Cyclic dependency${formatCycleNode(node)}`);
+        }
+        if (visited.has(node)) {
+            return;
+        }
+        visited.add(node);
+
+        const outgoing = [...(outgoingEdges.get(node) || [])];
+        if (outgoing.length) {
+            predecessors.add(node);
+            for (let index = outgoing.length - 1; index >= 0; index--) {
+                visit(outgoing[index], predecessors);
+            }
+            predecessors.delete(node);
+        }
+        sorted[--cursor] = node;
+    }
+
+    for (let index = nodes.length - 1; index >= 0; index--) {
+        visit(nodes[index], new Set());
+    }
+    return sorted;
+}
+
+/**
+ * Collect distinct graph endpoints in first-seen order.
+ *
+ * @template T
+ * @param {T[][]} edges directed graph edges
+ * @returns {T[]} unique endpoints
+ */
+function uniqueNodes(edges) {
+    const nodes = new Set();
+    for (const edge of edges) {
+        nodes.add(edge[0]);
+        nodes.add(edge[1]);
+    }
+    return [...nodes];
+}
+
+/**
+ * Build insertion-ordered outgoing-edge sets, deduplicating repeated edges.
+ *
+ * @template T
+ * @param {T[][]} edges directed graph edges
+ * @returns {Map.<T, Set.<T>>} outgoing endpoints per node
+ */
+function makeOutgoingEdges(edges) {
+    const outgoingEdges = new Map();
+    for (const [from, to] of edges) {
+        if (!outgoingEdges.has(from)) {
+            outgoingEdges.set(from, new Set());
+        }
+        if (!outgoingEdges.has(to)) {
+            outgoingEdges.set(to, new Set());
+        }
+        outgoingEdges.get(from).add(to);
+    }
+    return outgoingEdges;
+}
+
+/**
+ * Format a cycle endpoint without allowing unusual values to hide the cycle error.
+ *
+ * @param {unknown} node repeated graph endpoint
+ * @returns {string} package-compatible node suffix, or an empty string when serialization fails
+ */
+function formatCycleNode(node) {
+    try {
+        return `, node was:${JSON.stringify(node)}`;
+    } catch {
+        return '';
+    }
+}