@adhisang/minecraft-modding-mcp 6.1.1 → 6.2.0

package/dist/stage-emitter.js

@@ -15,15 +15,31 @@ export function makeStageEmitter(extra, options = {}) {
     if (requestId === undefined || typeof sendNotification !== "function") {
         return NOOP_STAGE_EMITTER;
     }
+    let deliveryPending = false;
     return async (stage, meta) => {
-        await sendNotification({
-            method: "$/stageUpdate",
-            params: {
-                stage,
-                meta: meta ?? null,
-                t: performance.now(),
-                requestId
-            }
+        if (deliveryPending) {
+            return;
+        }
+        let delivery;
+        try {
+            delivery = sendNotification({
+                method: "$/stageUpdate",
+                params: {
+                    stage,
+                    meta: meta ?? null,
+                    t: performance.now(),
+                    requestId
+                }
+            });
+        }
+        catch {
+            return;
+        }
+        deliveryPending = true;
+        void Promise.resolve(delivery)
+            .catch(() => undefined)
+            .finally(() => {
+            deliveryPending = false;
         });
     };
 }

package/dist/stdio-supervisor.d.ts

@@ -1,6 +1,36 @@
-import type { JSONRPCResponse } from "@modelcontextprotocol/sdk/types.js";
-type SupervisorOptions = {
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { JSONRPCMessage, JSONRPCResponse } from "@modelcontextprotocol/sdk/types.js";
+export declare function loadValidateProjectTimeoutMs(value?: string | undefined): number;
+export declare function computeWorkerStartupWatchdogMs(validateProjectTimeoutMs: number): number;
+export declare function computeRestartBackoffMs(retryIndex: number): number;
+export declare function terminatePosixProcessGroup(pid: number, kill?: (pid: number, signal: NodeJS.Signals) => void): boolean;
+export declare function buildWindowsTreeKillArgs(pid: number): string[];
+export declare function shouldRetainUnavailableNotification(method: string): boolean;
+export type RestartReservation = {
+    epoch: number;
+    notBefore: number;
+    delayMs: number;
+};
+export declare class RestartBackoffState {
+    private retryIndex;
+    private epoch;
+    reserve(now: number): RestartReservation;
+    reset(): void;
+}
+export declare function retryPosixTreeToken(pid: number, kill?: (pid: number, signal: NodeJS.Signals) => void): boolean;
+export declare function settleTreeCleanupWithin(operation: Promise<boolean>, timeoutMs: number, onTimeout?: () => void): Promise<boolean>;
+export type SupervisorOptions = {
     entryFile: string;
+    validateProjectTimeoutMs?: number;
+    clientWriter?: (message: JSONRPCMessage) => void;
+    treeTokenRetrier?: (pid: number) => boolean | Promise<boolean>;
+    treeCleanupTimeoutMs?: number;
+    eventWriter?: (level: "warn" | "error" | "info", event: string, details?: Record<string, unknown>) => void;
+    monotonicNow?: () => number;
+    timerScheduler?: (callback: () => void, delayMs: number) => NodeJS.Timeout;
+    timerClearer?: (timer: NodeJS.Timeout) => void;
+    workerSpawner?: () => ChildProcessWithoutNullStreams;
+    treeTerminator?: (pid: number) => boolean | Promise<boolean>;
 };
 type RequestId = string | number;
 export type ExitInfo = {
@@ -39,6 +69,15 @@ export type RedactedToolArgs = {
     modified: boolean;
 };
 export declare function redactToolArgs(args: unknown): RedactedToolArgs;
+export declare function buildSupervisorQueueLimitReply(id: RequestId, method: string): JSONRPCResponse;
+export type BuildValidateProjectTimeoutReplyInput = {
+    request: PendingRequestSnapshot;
+    phase: "queue" | "running";
+    deadlineMs: number;
+    now: number;
+    workerRestartInitiated: boolean;
+};
+export declare function buildValidateProjectTimeoutReply(input: BuildValidateProjectTimeoutReplyInput): JSONRPCResponse;
 export declare function decideRetryRecommendation(ctx: Pick<RestartContext, "toolName" | "lastStage" | "lastStageMeta" | "exit">, recentRestartTimestamps: number[]): RetryRecommendation;
 export declare function buildSyntheticCallToolResult(id: RequestId, ctx: RestartContext): JSONRPCResponse;
 export declare function pruneRestartTimestamps(timestamps: number[], now: number, windowMs?: number): number[];
@@ -62,15 +101,40 @@ export declare function buildWorkerRestartReply(req: PendingRequestSnapshot, exi
 };
 export declare class StdioSupervisor {
     private readonly entryFile;
+    private readonly validateProjectTimeoutMs;
+    private readonly workerStartupWatchdogMs;
+    private readonly clientWriter;
+    private readonly treeTokenRetrier;
+    private readonly treeCleanupTimeoutMs;
+    private readonly eventWriter;
+    private readonly monotonicNow;
+    private readonly timerScheduler;
+    private readonly timerClearer;
+    private readonly workerSpawner;
+    private readonly treeTerminator;
     private readonly clientReader;
-    private readonly workerReader;
-    private readonly queuedMessages;
+    private readonly workerReaders;
+    private readonly queuedRequests;
+    private readonly queuedNotifications;
     private readonly pendingRequests;
     private readonly recentRestarts;
+    private readonly liveChildren;
+    private readonly staleChildren;
+    private readonly cleanupStates;
+    private readonly unresolvedTreeTokens;
+    private readonly restartBackoff;
+    private readonly terminalChildren;
     private child;
     private childReady;
     private shuttingDown;
     private restartTimer;
+    private startupWatchdog;
+    private validateBarrierKey;
+    private runningValidateKey;
+    private attemptToken;
+    private currentRetryEpoch;
+    private currentRetryReservation;
+    private retryPaused;
     private workerStderrBuffer;
     private clientMode;
     private initializeRequest;
@@ -85,11 +149,17 @@ export declare class StdioSupervisor {
     private readonly handleClientClosed;
     private readonly handleTerminateSignal;
     private handleClientMessage;
-    private forwardToWorker;
+    private createPendingRequest;
+    private canDispatchImmediately;
+    private forwardRequest;
+    private writeToWorker;
+    private handleCancellation;
+    private handleValidateProjectDeadline;
+    private drainQueue;
     private spawnWorker;
-    private readonly handleWorkerData;
-    private readonly handleWorkerStdinError;
-    private readonly handleWorkerStderr;
+    private handleWorkerData;
+    private handleWorkerStdinError;
+    private handleWorkerStderr;
     private handleWorkerProcessError;
     private handleWorkerExit;
     private handleWorkerMessage;
@@ -99,8 +169,21 @@ export declare class StdioSupervisor {
     private flushQueue;
     private failPendingRequestsOnWorkerExit;
     private writeToClient;
+    private clearInitialInitializationState;
+    private liveCapOccupancy;
+    private clearStartupWatchdog;
+    private adoptActiveChild;
+    private invalidateCurrentChild;
+    private detachCurrentChild;
+    private recoverTimedOutWorker;
+    private beginTreeTermination;
+    private finishTreeTermination;
+    private retryUnresolvedTreeToken;
+    private handleStartupFailure;
+    private failQueuedRequestsOnStartupFailure;
     private scheduleRestart;
-    private detachChild;
+    private armRestartReservation;
+    private resumePausedRestart;
     private shutdown;
 }
 export declare const STDIO_WORKER_MODE_ENV = "MCP_STDIO_WORKER_MODE";