@zokizuan/satori-mcp 6.2.0 → 6.3.0

package/dist/server/shared-runtime-lifecycle.js

@@ -0,0 +1,259 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+function readBootId() {
+    return fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+}
+export function readLinuxProcessIdentity(pid = process.pid) {
+    try {
+        const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const commandEnd = raw.lastIndexOf(")");
+        if (commandEnd < 0)
+            return null;
+        const fieldsAfterCommand = raw.slice(commandEnd + 2).trim().split(/\s+/);
+        const startTime = fieldsAfterCommand[19];
+        if (!startTime)
+            return null;
+        return Object.freeze({
+            pid,
+            bootId: readBootId(),
+            startTime,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function isLinuxProcessIdentityLive(identity) {
+    const current = readLinuxProcessIdentity(identity.pid);
+    return current !== null
+        && current.bootId === identity.bootId
+        && current.startTime === identity.startTime;
+}
+function parseRecord(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readHostMetadata(metadataPath) {
+    try {
+        const record = parseRecord(fs.readFileSync(metadataPath, "utf8"));
+        if (!record
+            || record.formatVersion !== 1
+            || record.protocolVersion !== 1
+            || typeof record.hostPid !== "number"
+            || typeof record.bootId !== "string"
+            || typeof record.processStartTime !== "string"
+            || typeof record.mcpVersion !== "string"
+            || typeof record.sharedRuntimeIdentityHash !== "string"
+            || typeof record.installedRuntimeRoot !== "string"
+            || typeof record.ownershipToken !== "string"
+            || typeof record.socketPath !== "string"
+            || typeof record.socketDevice !== "number"
+            || typeof record.socketInode !== "number"
+            || typeof record.readyAt !== "string") {
+            return null;
+        }
+        return Object.freeze(record);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeHostMetadataAtomic(metadataPath, metadata) {
+    const temporary = `${metadataPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(metadata)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    fs.renameSync(temporary, metadataPath);
+}
+function readLockRecord(lockPath) {
+    try {
+        const record = parseRecord(fs.readFileSync(lockPath, "utf8"));
+        if (!record
+            || record.formatVersion !== 1
+            || typeof record.pid !== "number"
+            || typeof record.bootId !== "string"
+            || typeof record.processStartTime !== "string"
+            || typeof record.ownershipToken !== "string"
+            || typeof record.acquiredAt !== "string") {
+            return null;
+        }
+        return Object.freeze(record);
+    }
+    catch {
+        return null;
+    }
+}
+function sameFileIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function removeStaleLockWithoutReplacingNewOwner(lockPath) {
+    const claimPath = `${lockPath}.${process.pid}.${crypto.randomUUID()}.stale-claim`;
+    try {
+        fs.linkSync(lockPath, claimPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return true;
+        }
+        throw error;
+    }
+    try {
+        const claimedOwner = readLockRecord(claimPath);
+        if (claimedOwner
+            && isLinuxProcessIdentityLive({
+                pid: claimedOwner.pid,
+                bootId: claimedOwner.bootId,
+                startTime: claimedOwner.processStartTime,
+            })) {
+            return false;
+        }
+        let lockStat;
+        let claimStat;
+        try {
+            lockStat = fs.lstatSync(lockPath);
+            claimStat = fs.lstatSync(claimPath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return true;
+            }
+            throw error;
+        }
+        if (!sameFileIdentity(lockStat, claimStat) || claimStat.nlink !== 2) {
+            return false;
+        }
+        // Keep our hard-link claim until after unlinking the canonical name.
+        // Any concurrent stale cleaner then observes either a different inode,
+        // no canonical lock, or more than two links and cannot delete a
+        // replacement owner's lock.
+        fs.unlinkSync(lockPath);
+        return true;
+    }
+    finally {
+        try {
+            fs.unlinkSync(claimPath);
+        }
+        catch {
+            // The unique claim is non-authoritative after this attempt.
+        }
+    }
+}
+function wait(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+export async function acquireLifecycleLock(lockPath, timeoutMs = 10000) {
+    const current = readLinuxProcessIdentity();
+    if (!current) {
+        throw new Error("Cannot establish Linux process identity for shared runtime lifecycle lock.");
+    }
+    const ownershipToken = crypto.randomUUID();
+    const record = Object.freeze({
+        formatVersion: 1,
+        pid: current.pid,
+        bootId: current.bootId,
+        processStartTime: current.startTime,
+        ownershipToken,
+        acquiredAt: new Date().toISOString(),
+    });
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const candidatePath = `${lockPath}.${current.pid}.${ownershipToken}.candidate`;
+        try {
+            fs.writeFileSync(candidatePath, `${JSON.stringify(record)}\n`, {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            // A same-filesystem hard link publishes the complete owner record
+            // atomically without the empty-file window of open(O_EXCL)+write.
+            fs.linkSync(candidatePath, lockPath);
+            fs.unlinkSync(candidatePath);
+            let released = false;
+            return Object.freeze({
+                ownershipToken,
+                release() {
+                    if (released)
+                        return;
+                    released = true;
+                    const active = readLockRecord(lockPath);
+                    if (active?.ownershipToken === ownershipToken) {
+                        fs.unlinkSync(lockPath);
+                    }
+                },
+            });
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(candidatePath);
+            }
+            catch (cleanupError) {
+                if (cleanupError.code !== "ENOENT") {
+                    throw cleanupError;
+                }
+            }
+            const code = error.code;
+            if (code !== "EEXIST")
+                throw error;
+        }
+        const owner = readLockRecord(lockPath);
+        const ownerLive = owner
+            ? isLinuxProcessIdentityLive({
+                pid: owner.pid,
+                bootId: owner.bootId,
+                startTime: owner.processStartTime,
+            })
+            : false;
+        if (!ownerLive && removeStaleLockWithoutReplacingNewOwner(lockPath)) {
+            continue;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out waiting for shared runtime lifecycle lock '${lockPath}'.`);
+        }
+        await wait(25);
+    }
+}
+export function metadataMatchesIdentity(metadata, identity) {
+    return metadata.sharedRuntimeIdentityHash === identity.hash
+        && metadata.mcpVersion === identity.mcpVersion
+        && path.resolve(metadata.installedRuntimeRoot) === path.resolve(identity.installedRuntimeRoot);
+}
+export function removeOwnedLifecycleState(paths, expected) {
+    const current = readHostMetadata(paths.metadataPath);
+    if (!current
+        || current.hostPid !== expected.hostPid
+        || current.bootId !== expected.bootId
+        || current.processStartTime !== expected.processStartTime
+        || current.ownershipToken !== expected.ownershipToken
+        || current.sharedRuntimeIdentityHash !== expected.sharedRuntimeIdentityHash
+        || current.socketPath !== expected.socketPath
+        || current.socketDevice !== expected.socketDevice
+        || current.socketInode !== expected.socketInode) {
+        return;
+    }
+    try {
+        const socket = fs.lstatSync(expected.socketPath);
+        if (socket.isSocket()
+            && socket.dev === expected.socketDevice
+            && socket.ino === expected.socketInode) {
+            fs.unlinkSync(expected.socketPath);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const stillCurrent = readHostMetadata(paths.metadataPath);
+    if (stillCurrent?.ownershipToken === expected.ownershipToken) {
+        fs.unlinkSync(paths.metadataPath);
+    }
+}
+//# sourceMappingURL=shared-runtime-lifecycle.js.map

package/dist/server/shared-runtime-transport.d.ts

@@ -0,0 +1,28 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage, MessageExtraInfo } from "@modelcontextprotocol/sdk/types.js";
+import type { Socket } from "node:net";
+export declare class BoundedSocketTransport implements Transport {
+    private readonly socket;
+    private readonly onSocketClosed;
+    private readonly maximumMessageBytes;
+    private readonly maximumPendingRequests;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: <T extends JSONRPCMessage>(message: T, extra?: MessageExtraInfo) => void;
+    private buffer;
+    private readonly pendingRequests;
+    private started;
+    private closed;
+    constructor(socket: Socket, onSocketClosed: () => void, initialBytes?: Buffer, maximumMessageBytes?: number, maximumPendingRequests?: number);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+    private readonly handleData;
+    private processBuffer;
+    private processCompleteLine;
+    private readonly handleError;
+    private readonly handleClose;
+    private fail;
+    private detach;
+}
+//# sourceMappingURL=shared-runtime-transport.d.ts.map

package/dist/server/shared-runtime-transport.js

@@ -0,0 +1,158 @@
+import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
+import { SHARED_RUNTIME_MAX_PENDING_REQUESTS, SHARED_RUNTIME_MESSAGE_MAX_BYTES, } from "./shared-runtime-identity.js";
+function requestKey(message) {
+    if (!("method" in message) || !("id" in message))
+        return null;
+    return `${typeof message.id}:${String(message.id)}`;
+}
+function responseKey(message) {
+    if (!("id" in message)
+        || (!("result" in message) && !("error" in message))) {
+        return null;
+    }
+    return `${typeof message.id}:${String(message.id)}`;
+}
+export class BoundedSocketTransport {
+    constructor(socket, onSocketClosed, initialBytes, maximumMessageBytes = SHARED_RUNTIME_MESSAGE_MAX_BYTES, maximumPendingRequests = SHARED_RUNTIME_MAX_PENDING_REQUESTS) {
+        this.socket = socket;
+        this.onSocketClosed = onSocketClosed;
+        this.maximumMessageBytes = maximumMessageBytes;
+        this.maximumPendingRequests = maximumPendingRequests;
+        this.buffer = Buffer.alloc(0);
+        this.pendingRequests = new Set();
+        this.started = false;
+        this.closed = false;
+        this.handleData = (chunk) => {
+            if (this.closed)
+                return;
+            let offset = 0;
+            while (offset < chunk.length && !this.closed) {
+                const newline = chunk.indexOf(0x0a, offset);
+                const end = newline < 0 ? chunk.length : newline;
+                const segment = chunk.subarray(offset, end);
+                if (this.buffer.length + segment.length > this.maximumMessageBytes) {
+                    this.fail(new Error(`Shared runtime JSON-RPC frame exceeds ${this.maximumMessageBytes} bytes.`));
+                    return;
+                }
+                if (segment.length > 0) {
+                    this.buffer = this.buffer.length === 0
+                        ? Buffer.from(segment)
+                        : Buffer.concat([this.buffer, segment]);
+                }
+                if (newline < 0)
+                    return;
+                this.processCompleteLine();
+                offset = newline + 1;
+            }
+        };
+        this.handleError = (error) => {
+            this.onerror?.(error);
+        };
+        this.handleClose = () => {
+            if (this.closed)
+                return;
+            this.closed = true;
+            this.detach();
+            this.onSocketClosed();
+            this.onclose?.();
+        };
+        if (initialBytes && initialBytes.length > 0) {
+            this.buffer = Buffer.from(initialBytes);
+        }
+    }
+    async start() {
+        if (this.started) {
+            throw new Error("Bounded socket transport is already started.");
+        }
+        this.started = true;
+        this.socket.on("data", this.handleData);
+        this.socket.on("error", this.handleError);
+        this.socket.on("close", this.handleClose);
+        if (this.buffer.length > 0) {
+            this.processBuffer();
+        }
+        this.socket.resume();
+    }
+    async send(message) {
+        if (this.closed || this.socket.destroyed) {
+            throw new Error("Shared runtime session transport is closed.");
+        }
+        const completedRequest = responseKey(message);
+        if (completedRequest !== null) {
+            this.pendingRequests.delete(completedRequest);
+        }
+        const serialized = `${JSON.stringify(message)}\n`;
+        await new Promise((resolve, reject) => {
+            this.socket.write(serialized, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.detach();
+        if (!this.socket.destroyed) {
+            this.socket.destroy();
+        }
+        this.onSocketClosed();
+        this.onclose?.();
+    }
+    processBuffer() {
+        for (;;) {
+            const newline = this.buffer.indexOf(0x0a);
+            if (newline < 0) {
+                if (this.buffer.length > this.maximumMessageBytes) {
+                    this.fail(new Error(`Shared runtime JSON-RPC frame exceeds ${this.maximumMessageBytes} bytes.`));
+                }
+                return;
+            }
+            const line = this.buffer.subarray(0, newline);
+            this.buffer = this.buffer.subarray(newline + 1);
+            if (line.length === 0)
+                continue;
+            this.processCompleteLine(line);
+        }
+    }
+    processCompleteLine(line) {
+        const completeLine = line ?? this.buffer;
+        if (line === undefined) {
+            this.buffer = Buffer.alloc(0);
+        }
+        const serialized = completeLine.toString("utf8").replace(/\r$/, "");
+        if (!serialized)
+            return;
+        try {
+            const message = JSONRPCMessageSchema.parse(JSON.parse(serialized));
+            const pendingRequest = requestKey(message);
+            if (pendingRequest !== null) {
+                if (this.pendingRequests.has(pendingRequest)
+                    || this.pendingRequests.size >= this.maximumPendingRequests) {
+                    this.fail(new Error(`Shared runtime session exceeds ${this.maximumPendingRequests} pending requests.`));
+                    return;
+                }
+                this.pendingRequests.add(pendingRequest);
+            }
+            this.onmessage?.(message);
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    fail(error) {
+        this.onerror?.(error);
+        void this.close();
+    }
+    detach() {
+        this.socket.off("data", this.handleData);
+        this.socket.off("error", this.handleError);
+        this.socket.off("close", this.handleClose);
+        this.buffer = Buffer.alloc(0);
+        this.pendingRequests.clear();
+    }
+}
+//# sourceMappingURL=shared-runtime-transport.js.map

package/dist/server/shared-runtime.d.ts

@@ -0,0 +1,83 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { Readable, Writable } from "node:stream";
+import type { ContextMcpConfig, IndexFingerprint } from "../config.js";
+import { CallGraphSidecarManager } from "../core/call-graph.js";
+import { SearchContinuationCoordinator, ToolHandlers } from "../core/handlers.js";
+import { MutationLeaseCoordinator } from "../core/mutation-lease.js";
+import type { MissingProviderConfigIssue, ProviderBackedOperation, ToolContext } from "../tools/types.js";
+import { ProviderRuntime } from "./provider-runtime.js";
+export type ServerRunMode = "mcp" | "cli" | "postflight" | "host";
+declare class SessionProviderRuntime {
+    private readonly providerRuntime;
+    private readonly continuationCoordinator;
+    private readonly mutationLeaseCoordinator;
+    private readonly callGraphManager;
+    private readonly contexts;
+    private readonly handlers;
+    constructor(providerRuntime: ProviderRuntime, continuationCoordinator: SearchContinuationCoordinator, mutationLeaseCoordinator: MutationLeaseCoordinator, callGraphManager: CallGraphSidecarManager);
+    requireToolContext(operation: ProviderBackedOperation): Promise<ToolContext | MissingProviderConfigIssue>;
+    release(): void;
+}
+type SessionResources = {
+    toolContext: ToolContext;
+    localHandlers: ToolHandlers;
+    providerRuntime: SessionProviderRuntime;
+};
+export declare class SharedRuntimeHost {
+    readonly config: ContextMcpConfig;
+    readonly runtimeFingerprint: IndexFingerprint;
+    readonly runMode: ServerRunMode;
+    private readonly capabilities;
+    private readonly snapshotManager;
+    private readonly callGraphManager;
+    private readonly runtimeOwnerRegistry;
+    private readonly mutationLeaseCoordinator;
+    private readonly localContext;
+    private readonly localSyncManager;
+    private readonly recoveryHandlers;
+    private readonly providerRuntime;
+    private readonly readFileMaxLines;
+    private readonly watchSyncEnabled;
+    private readonly watchDebounceMs;
+    private activeSessions;
+    private activeOperations;
+    private shutdownStarted;
+    private readonly activityListeners;
+    constructor(config: ContextMcpConfig, runtimeFingerprint: IndexFingerprint, runMode: ServerRunMode);
+    createSession(): McpSession;
+    createSessionResources(continuationCoordinator: SearchContinuationCoordinator): SessionResources;
+    registerSession(): void;
+    unregisterSession(): void;
+    beginOperation(): void;
+    endOperation(): void;
+    getActivity(): Readonly<{
+        sessions: number;
+        operations: number;
+    }>;
+    getProviderRuntime(): ProviderRuntime;
+    subscribeActivity(listener: () => void): () => void;
+    private notifyActivityChanged;
+    recoverInterruptedIndexingAtStartup(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export declare class McpSession {
+    private readonly host;
+    private readonly server;
+    private readonly continuationCoordinator;
+    private readonly resources;
+    private activeToolCalls;
+    private connected;
+    private closed;
+    private resourcesReleased;
+    private resourceReleasePromise;
+    private resolveResourceRelease;
+    private keepAliveTimer;
+    constructor(host: SharedRuntimeHost);
+    private setupTools;
+    connect(transport: Transport, resumeInput?: Readable): Promise<void>;
+    connectStdio(input?: Readable, output?: Writable): Promise<void>;
+    shutdown(): Promise<void>;
+    private releaseResourcesIfIdle;
+}
+export {};
+//# sourceMappingURL=shared-runtime.d.ts.map