ast-mcp-server 0.6.0 → 0.7.0

package/dist/services/project-status.js

@@ -1,4 +1,7 @@
 import { createHash } from "node:crypto";
+import { types as utilTypes } from "node:util";
+import { MAX_PROJECT_OPERATION_COUNTER, MAX_PROJECT_OPERATION_DURATION_MS, } from "./project-operation-scheduler.js";
+import { sanitizeSensitiveText } from "./public-errors.js";
 import { createTruncationMetadata, isFreshnessCause, isSnapshotState, isTruncationReason, } from "./read-contracts.js";
 export const MAX_PENDING_FILES = 64;
 export const MAX_PENDING_FILENAME_LENGTH = 256;
@@ -85,42 +88,12 @@ function boundedCount(value) {
         return 0;
     return value;
 }
-function redactAbsolutePaths(value) {
-    const traversalMarker = "__TRAVERSAL_PATH_REDACTED__";
-    const quotedTraversalPath = /(?<=["'`])(?:[^"'`\n\r]*[\\/])?\.\.[\\/][^"'`\n\r]*?(?=["'`])/g;
-    const labelledTraversalPath = /([=:]\s+)([^"'`:\n\r;,]*[ \t]+[^"'`:\n\r;,/\\]+[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
-    const diagnosticTraversalPath = /(\b(?:read|open|resolve|watch|parse)\s+)([^"'`:\n\r;,]*[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/gi;
-    const spacedTraversalPath = /(?<=\s)([^"'`:\n\r;,]*[ \t]+[^"'`:\n\r;,/\\]+[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
-    const relativeTraversalPath = /(?:[^\s"'`:/${}\\]+[\\/])+\.\.[\\/][^"'`:\n\r]*?(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
-    const directTraversalPath = /(?:^|(?<=[\s(]))\.\.[\\/][^"'`:\n\r]*?(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
-    const uncPath = /(?:\\\\|\/{2})[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
-    const drivePath = /\b[A-Za-z]:[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
-    const posixPath = /(?<![A-Za-z0-9_./-])\/(?!\/)[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
-    const redacted = value
-        .replace(quotedTraversalPath, traversalMarker)
-        .replace(labelledTraversalPath, `$1${traversalMarker}`)
-        .replace(diagnosticTraversalPath, `$1${traversalMarker}`)
-        .replace(spacedTraversalPath, traversalMarker)
-        .replace(relativeTraversalPath, traversalMarker)
-        .replace(directTraversalPath, traversalMarker);
-    return redacted
-        .replace(drivePath, "[path-redacted]")
-        .replace(uncPath, "[path-redacted]")
-        .replace(posixPath, "[path-redacted]")
-        .replaceAll(traversalMarker, "[path-redacted]");
-}
-function redactSensitiveText(value) {
-    return value
-        .replace(/(?!(?:\bauthorization[ \t]*[:=])[ \t]*\[REDACTED\])(\bauthorization[ \t]*[:=])([ \t]*)[^\r\n;]+/gi, "$1$2[REDACTED]")
-        .replace(/(?!(?:\bbearer)[ \t]+\[REDACTED\])\bbearer[ \t]+[^\r\n;]+/gi, "Bearer [REDACTED]")
-        .replace(/\b(api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|token|password|secret|credential|connection[-_ ]?string)\b\s*[:=]\s*(?!\[REDACTED\])(?:"[^"]*"|'[^']*'|[^\s,;}\]]+)/gi, "$1=[REDACTED]")
-        .replace(/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^\s"'`]+@/g, "$1[REDACTED]@")
-        .replace(/\b(?:sk|ghp|github_pat|xox[baprs]-|AIza)[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]");
-}
+const MAX_STATUS_TEXT_INPUT_CHARS = 8192;
 function boundedText(value) {
     const text = typeof value === "string" ? value : "[invalid-error]";
-    const redacted = redactSensitiveText(redactAbsolutePaths(text));
-    return redacted.length <= MAX_STATUS_TEXT_LENGTH
+    const inputTruncated = text.length > MAX_STATUS_TEXT_INPUT_CHARS;
+    const redacted = sanitizeSensitiveText(text.slice(0, MAX_STATUS_TEXT_INPUT_CHARS));
+    return !inputTruncated && redacted.length <= MAX_STATUS_TEXT_LENGTH
         ? { value: redacted, truncated: false }
         : {
             value: `${redacted.slice(0, MAX_STATUS_TEXT_LENGTH - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}`,
@@ -437,12 +410,12 @@ function normalizeProjectStatus(status) {
         causes,
         boundaryInvalid,
         sourceCount: boundedCount(status.sourceCount),
-        indexedCount: 0,
-        index: { state: "disabled" },
+        indexedCount: rawIndexState === "disabled" ? 0 : boundedCount(status.indexedCount),
+        index: { state: isIndexStatusState(rawIndexState) ? rawIndexState : "failed" },
         compiler: { state: compilerValid ? rawCompilerState : "failed" },
         watcher: { state: watcherFailed ? "failed" : rawWatcherState },
         lastSuccessfulSyncAt,
-        lastSuccessfulIndexAt: null,
+        lastSuccessfulIndexAt: rawIndexState === "disabled" ? null : normalizedTimestamp(status.lastSuccessfulIndexAt),
         sourceSnapshotFingerprint,
         configSnapshotFingerprint,
         canonicalSnapshotFingerprint,
@@ -551,9 +524,11 @@ export function transitionProjectStatus(inputStatus, event) {
                 causes: appendCause(status.causes, "compiler_rebuild"),
                 compiler: { state: "rebuilding" },
                 index: {
-                    state: hasActiveIndexFailure(status) || status.index.state === "disabled"
-                        ? "disabled"
-                        : "rebuilding",
+                    state: status.index.state === "failed"
+                        ? "failed"
+                        : status.index.state === "disabled"
+                            ? "disabled"
+                            : "rebuilding",
                 },
             });
         case "sync_succeeded": {
@@ -561,7 +536,9 @@ export function transitionProjectStatus(inputStatus, event) {
                 return markInvalidTransition(status, "[invalid-count]");
             }
             const hasFailure = hasActiveComponentFailure(status);
-            const indexDisabled = hasActiveIndexFailure(status) || status.index.state === "disabled";
+            const indexUnavailable = hasActiveIndexFailure(status) ||
+                status.index.state === "disabled" ||
+                status.index.state === "failed";
             const sourceSnapshotFingerprint = nonEmptyFingerprint(event.sourceSnapshotFingerprint, "source");
             const configSnapshotFingerprint = nonEmptyFingerprint(event.configSnapshotFingerprint, "config");
             const canonicalSnapshotFingerprint = nonEmptyFingerprint(event.canonicalSnapshotFingerprint, "snapshot");
@@ -588,21 +565,21 @@ export function transitionProjectStatus(inputStatus, event) {
                 state: nextState,
                 causes: canClearInvalidation ? [] : status.causes,
                 sourceCount: boundedCount(event.sourceCount),
-                indexedCount: indexDisabled ? 0 : boundedCount(event.indexedCount),
+                indexedCount: indexUnavailable ? 0 : boundedCount(event.indexedCount),
                 pendingFiles: pending.files,
                 pendingFilesTruncated: pending.recordTruncation.truncated || pending.filenameTruncation.truncated,
                 pendingFilesTruncation: pending.recordTruncation,
                 pendingFilesFilenameTruncation: pending.filenameTruncation,
                 compiler: { state: "ready" },
                 index: {
-                    state: indexDisabled
-                        ? "disabled"
-                        : hasFailure && status.index.state === "failed"
-                            ? "failed"
+                    state: hasFailure && status.index.state === "failed"
+                        ? "failed"
+                        : indexUnavailable
+                            ? "disabled"
                             : "ready",
                 },
                 lastSuccessfulSyncAt: canClearInvalidation ? nextSyncAt : status.lastSuccessfulSyncAt,
-                lastSuccessfulIndexAt: !hasFreshEvidence || indexDisabled || (hasFailure && status.index.state === "failed")
+                lastSuccessfulIndexAt: !hasFreshEvidence || indexUnavailable
                     ? status.lastSuccessfulIndexAt
                     : (nextSyncAt ?? status.lastSuccessfulIndexAt),
                 sourceSnapshotFingerprint: hasSnapshotEvidence
@@ -659,7 +636,7 @@ export function transitionProjectStatus(inputStatus, event) {
             return statusWith(status, {
                 state: "degraded",
                 causes: appendCause(status.causes, "index_failure"),
-                index: { state: "disabled" },
+                index: { state: "failed" },
                 degradedErrors: appended.errors,
                 degradedErrorsTruncation: errorTruncation(countTruncated, textTruncated),
                 degradedErrorsTextTruncation: createTruncationMetadata(textTruncated, textTruncated ? "serialization_limit" : null),
@@ -685,6 +662,15 @@ export function transitionProjectStatus(inputStatus, event) {
             return recoverComponent(status, event.component);
         case "index_recovered":
             return recoverComponent(status, "index");
+        case "index_ready":
+            return statusWith(status, { index: { state: "ready" } });
+        case "index_disabled":
+            return statusWith(status, {
+                index: { state: "disabled" },
+                indexedCount: 0,
+                lastSuccessfulIndexAt: null,
+                causes: removeCause(status.causes, "index_failure"),
+            });
         case "watcher_recovered":
             return recoverComponent(status, "watcher");
         default:
@@ -694,7 +680,7 @@ export function transitionProjectStatus(inputStatus, event) {
 function recoverComponent(status, component) {
     const recovered = component === "index"
         ? statusWith(status, {
-            index: { state: "disabled" },
+            index: { state: status.index.state === "failed" ? "ready" : status.index.state },
             causes: removeCause(status.causes, "index_failure"),
         })
         : statusWith(status, {
@@ -716,16 +702,16 @@ export function projectStatusToProjection(status) {
         state: normalized.state,
         causes: [...normalized.causes],
         source_count: normalized.sourceCount,
-        indexed_count: 0,
+        indexed_count: normalized.indexedCount,
         pending_files: [...normalized.pendingFiles],
         pending_files_truncated: normalized.pendingFilesTruncated,
         pending_files_truncation: { ...normalized.pendingFilesTruncation },
         pending_files_filename_truncation: { ...normalized.pendingFilesFilenameTruncation },
         compiler: { ...normalized.compiler },
-        index: { state: "disabled" },
+        index: { ...normalized.index },
         watcher: { ...normalized.watcher },
         last_successful_sync_at: normalized.lastSuccessfulSyncAt,
-        last_successful_index_at: null,
+        last_successful_index_at: normalized.lastSuccessfulIndexAt,
         source_snapshot_fingerprint: normalized.sourceSnapshotFingerprint,
         config_snapshot_fingerprint: normalized.configSnapshotFingerprint,
         canonical_snapshot_fingerprint: normalized.canonicalSnapshotFingerprint,
@@ -734,3 +720,99 @@ export function projectStatusToProjection(status) {
         degraded_errors_text_truncation: { ...normalized.degradedErrorsTextTruncation },
     };
 }
+const OPERATION_QUEUE_FIELDS = Object.freeze([
+    "admission",
+    "queue_capacity",
+    "active_operations",
+    "queued_operations",
+    "rejected_operations",
+    "cancelled_operations",
+    "queue_timeout_operations",
+    "deadline_exceeded_operations",
+    "last_outcome",
+    "max_queue_wait_ms",
+    "max_execution_ms",
+]);
+function operationQueueRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return {};
+    try {
+        if (utilTypes.isProxy(value) || Array.isArray(value))
+            return {};
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return {};
+        const ownKeys = Reflect.ownKeys(value);
+        if (ownKeys.some((key) => typeof key === "symbol"))
+            return {};
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        for (const key of ownKeys) {
+            const descriptor = descriptors[key];
+            if (!descriptor?.enumerable || !("value" in descriptor))
+                return {};
+        }
+        const record = Object.create(null);
+        for (const field of OPERATION_QUEUE_FIELDS) {
+            const descriptor = descriptors[field];
+            if (descriptor && "value" in descriptor)
+                record[field] = descriptor.value;
+        }
+        return record;
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeQueueCapacity(value, configuredCapacity) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 256) {
+        return value;
+    }
+    if (typeof configuredCapacity === "number" &&
+        Number.isSafeInteger(configuredCapacity) &&
+        configuredCapacity >= 1 &&
+        configuredCapacity <= 256) {
+        return configuredCapacity;
+    }
+    return 32;
+}
+function normalizeRuntimeMetric(value, maximum) {
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    return Math.min(value, maximum);
+}
+function normalizeOperationOutcome(value) {
+    if (value === "none" ||
+        value === "succeeded" ||
+        value === "failed" ||
+        value === "rejected" ||
+        value === "cancelled" ||
+        value === "queue_timeout" ||
+        value === "deadline_exceeded" ||
+        value === "internal_error") {
+        return value;
+    }
+    return "internal_error";
+}
+export function projectOperationQueueToProjection(input, configuredCapacity) {
+    const record = operationQueueRecord(input);
+    const queueCapacity = normalizeQueueCapacity(record.queue_capacity, configuredCapacity);
+    const activeOperations = normalizeRuntimeMetric(record.active_operations, 1);
+    const queuedOperations = normalizeRuntimeMetric(record.queued_operations, queueCapacity);
+    const state = activeOperations > 0 ? "running" : queuedOperations > 0 ? "queued" : "idle";
+    return Object.freeze({
+        state,
+        admission: record.admission === "open" ? "open" : "closed",
+        queue_capacity: queueCapacity,
+        active_operations: activeOperations,
+        queued_operations: queuedOperations,
+        rejected_operations: normalizeRuntimeMetric(record.rejected_operations, MAX_PROJECT_OPERATION_COUNTER),
+        cancelled_operations: normalizeRuntimeMetric(record.cancelled_operations, MAX_PROJECT_OPERATION_COUNTER),
+        queue_timeout_operations: normalizeRuntimeMetric(record.queue_timeout_operations, MAX_PROJECT_OPERATION_COUNTER),
+        deadline_exceeded_operations: normalizeRuntimeMetric(record.deadline_exceeded_operations, MAX_PROJECT_OPERATION_COUNTER),
+        last_outcome: normalizeOperationOutcome(record.last_outcome),
+        max_queue_wait_ms: normalizeRuntimeMetric(record.max_queue_wait_ms, MAX_PROJECT_OPERATION_DURATION_MS),
+        max_execution_ms: normalizeRuntimeMetric(record.max_execution_ms, MAX_PROJECT_OPERATION_DURATION_MS),
+    });
+}

package/dist/services/project-watcher.js

@@ -0,0 +1,230 @@
+import fs from "node:fs";
+import path from "node:path";
+export const DEFAULT_WATCHER_DEBOUNCE_MS = 100;
+export const DEFAULT_MAX_PENDING_PATHS = 65;
+export const DEFAULT_MAX_WATCHED_DIRECTORIES = 512;
+const IGNORED_DIRECTORY_NAMES = new Set([".git", ".yarn", "coverage", "dist", "node_modules"]);
+function defaultWatchFactory(directory, onEvent, onError) {
+    const watcher = fs.watch(directory, { persistent: false }, onEvent);
+    watcher.on("error", onError);
+    return watcher;
+}
+function boundedInteger(value, fallback, minimum) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < minimum) {
+        throw new Error(`Watcher numeric options must be integers >= ${minimum}.`);
+    }
+    return value;
+}
+function normalizeDirectory(projectRoot, directory) {
+    const normalizedRoot = fs.realpathSync(path.resolve(projectRoot));
+    const normalizedDirectory = fs.realpathSync(path.resolve(directory));
+    if (normalizedDirectory !== normalizedRoot &&
+        !normalizedDirectory.startsWith(`${normalizedRoot}${path.sep}`)) {
+        throw new Error(`Watcher directory must stay inside the project root: ${directory}.`);
+    }
+    return normalizedDirectory;
+}
+export function selectProjectWatchDirectories(projectRoot, sourceFilePaths) {
+    const normalizedRoot = fs.realpathSync(path.resolve(projectRoot));
+    const directories = new Set([normalizedRoot]);
+    for (const sourceFilePath of sourceFilePaths) {
+        let directory = path.dirname(path.resolve(sourceFilePath));
+        while (directory === normalizedRoot || directory.startsWith(`${normalizedRoot}${path.sep}`)) {
+            const relativeParts = path.relative(normalizedRoot, directory).split(path.sep);
+            if (relativeParts.some((part) => IGNORED_DIRECTORY_NAMES.has(part)))
+                break;
+            let physicalDirectory;
+            try {
+                physicalDirectory = fs.realpathSync(directory);
+            }
+            catch {
+                break;
+            }
+            if (physicalDirectory !== normalizedRoot &&
+                !physicalDirectory.startsWith(`${normalizedRoot}${path.sep}`)) {
+                break;
+            }
+            directories.add(physicalDirectory);
+            if (directory === normalizedRoot)
+                break;
+            directory = path.dirname(directory);
+        }
+    }
+    return [...directories].sort((left, right) => left.split(path.sep).length - right.split(path.sep).length || left.localeCompare(right));
+}
+function discoverDirectories(projectRoot, maxDirectories) {
+    const directories = [projectRoot];
+    for (let index = 0; index < directories.length; index += 1) {
+        const directory = directories[index];
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() ||
+                entry.isSymbolicLink() ||
+                IGNORED_DIRECTORY_NAMES.has(entry.name)) {
+                continue;
+            }
+            directories.push(path.join(directory, entry.name));
+            if (directories.length > maxDirectories) {
+                throw new Error(`Watcher directory limit exceeded (${maxDirectories}).`);
+            }
+        }
+    }
+    return directories;
+}
+function normalizeFilename(projectRoot, watchedDirectory, filename) {
+    const filenameText = filename === null ? "" : filename.toString();
+    const absolutePath = filenameText
+        ? path.resolve(watchedDirectory, filenameText)
+        : watchedDirectory;
+    const relativePath = path.relative(projectRoot, absolutePath).split(path.sep).join("/");
+    if (relativePath === "" ||
+        relativePath === "." ||
+        relativePath.startsWith("../") ||
+        path.isAbsolute(relativePath)) {
+        return ".";
+    }
+    return relativePath;
+}
+function createWatcher(options) {
+    if (typeof options.onChange !== "function" || typeof options.onError !== "function") {
+        throw new Error("Watcher callbacks must be functions.");
+    }
+    const projectRoot = fs.realpathSync(path.resolve(options.projectRoot));
+    const debounceMs = boundedInteger(options.debounceMs, DEFAULT_WATCHER_DEBOUNCE_MS, 0);
+    const maxPendingPaths = boundedInteger(options.maxPendingPaths, DEFAULT_MAX_PENDING_PATHS, 1);
+    const maxWatchedDirectories = boundedInteger(options.maxWatchedDirectories, DEFAULT_MAX_WATCHED_DIRECTORIES, 1);
+    const watchFactory = options.watchFactory ?? defaultWatchFactory;
+    const configuredDirectories = options.directories === undefined
+        ? undefined
+        : [
+            ...new Set(options.directories.map((directory) => normalizeDirectory(projectRoot, directory))),
+        ];
+    let state = "disabled";
+    let handles = [];
+    let pendingPaths = new Map();
+    let pendingPathsTruncated = false;
+    let timer;
+    const clearPendingTimer = () => {
+        if (timer === undefined)
+            return;
+        clearTimeout(timer);
+        timer = undefined;
+    };
+    const closeHandles = () => {
+        const currentHandles = handles;
+        handles = [];
+        for (const handle of currentHandles) {
+            try {
+                handle.close();
+            }
+            catch {
+                // Closing an already-failed native watcher is best effort.
+            }
+        }
+    };
+    const notifyError = (error) => {
+        try {
+            options.onError(error);
+        }
+        catch {
+            // Observer errors must not escape the filesystem callback.
+        }
+    };
+    const markFailed = (error) => {
+        if (state === "disabled" && handles.length === 0)
+            return;
+        clearPendingTimer();
+        pendingPaths = new Map();
+        pendingPathsTruncated = false;
+        closeHandles();
+        state = "failed";
+        notifyError(error);
+    };
+    const flush = () => {
+        timer = undefined;
+        if (state !== "ready" || pendingPaths.size === 0)
+            return;
+        const files = [...pendingPaths.keys()];
+        pendingPaths = new Map();
+        pendingPathsTruncated = false;
+        try {
+            options.onChange(files);
+        }
+        catch (error) {
+            markFailed(error);
+        }
+    };
+    const scheduleFlush = () => {
+        clearPendingTimer();
+        timer = setTimeout(flush, debounceMs);
+    };
+    const handleEvent = (watchedDirectory, _eventType, filename) => {
+        if (state !== "ready")
+            return;
+        const relativePath = normalizeFilename(projectRoot, watchedDirectory, filename);
+        if (!pendingPaths.has(relativePath)) {
+            if (pendingPaths.size >= maxPendingPaths) {
+                pendingPathsTruncated = true;
+                markFailed(new Error(`Watcher event limit exceeded (${maxPendingPaths} paths).`));
+                return;
+            }
+            else {
+                pendingPaths.set(relativePath, true);
+            }
+        }
+        scheduleFlush();
+    };
+    return {
+        start() {
+            if (state === "ready")
+                return;
+            clearPendingTimer();
+            pendingPaths = new Map();
+            pendingPathsTruncated = false;
+            const nextHandles = [];
+            try {
+                const directories = configuredDirectories ?? discoverDirectories(projectRoot, maxWatchedDirectories);
+                if (directories.length > maxWatchedDirectories) {
+                    throw new Error(`Watcher directory limit exceeded (${maxWatchedDirectories}).`);
+                }
+                for (const directory of directories) {
+                    nextHandles.push(watchFactory(directory, (eventType, filename) => handleEvent(directory, eventType, filename), markFailed));
+                }
+                handles = nextHandles;
+                state = "ready";
+            }
+            catch (error) {
+                for (const handle of nextHandles) {
+                    try {
+                        handle.close();
+                    }
+                    catch {
+                        // Partial startup cleanup is best effort.
+                    }
+                }
+                state = "failed";
+                notifyError(error);
+            }
+        },
+        close() {
+            clearPendingTimer();
+            pendingPaths = new Map();
+            pendingPathsTruncated = false;
+            closeHandles();
+            state = "disabled";
+        },
+        snapshot() {
+            return {
+                state,
+                watched_directories: handles.length,
+                pending_paths: [...pendingPaths.keys()],
+                pending_paths_truncated: pendingPathsTruncated,
+            };
+        },
+    };
+}
+export function createProjectWatcher(options) {
+    return createWatcher(options);
+}