opencode-graphiti 0.1.10 → 0.1.12

package/esm/src/services/connection-manager.js

@@ -0,0 +1,535 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import manifest from "../../deno.js";
+import { logger } from "./logger.js";
+export class GraphitiOfflineError extends Error {
+    constructor(state, message) {
+        super(message ??
+            (state === "closing"
+                ? "Graphiti connection manager is closing"
+                : "Graphiti connection manager is offline"));
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "offline"
+        });
+        this.name = "GraphitiOfflineError";
+    }
+}
+export class GraphitiQueueTimeoutError extends Error {
+    constructor(message = "Graphiti request timed out while waiting for connection") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "queue-timeout"
+        });
+        this.name = "GraphitiQueueTimeoutError";
+    }
+}
+export class GraphitiRequestTimeoutError extends Error {
+    constructor(message = "Graphiti request timed out") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "request-timeout"
+        });
+        this.name = "GraphitiRequestTimeoutError";
+    }
+}
+export class GraphitiTransportError extends Error {
+    constructor(message = "Graphiti transport failure") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "transport-failure"
+        });
+        this.name = "GraphitiTransportError";
+    }
+}
+export class GraphitiSessionExpiredError extends Error {
+    constructor(message = "Graphiti session expired") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "session-expired"
+        });
+        this.name = "GraphitiSessionExpiredError";
+    }
+}
+export function isGraphitiOfflineError(err) {
+    return err instanceof GraphitiOfflineError;
+}
+export function isGraphitiTimeoutError(err) {
+    return err instanceof GraphitiQueueTimeoutError ||
+        err instanceof GraphitiRequestTimeoutError;
+}
+function createMcpConnection(endpoint) {
+    const client = new Client({
+        name: manifest.name,
+        version: manifest.version,
+    });
+    const transport = new StreamableHTTPClientTransport(new URL(endpoint));
+    return {
+        connect: () => client.connect(transport),
+        close: () => client.close(),
+        callTool: (request) => client.callTool(request),
+    };
+}
+function getErrorMessage(err) {
+    if (typeof err === "string")
+        return err;
+    if (!err || typeof err !== "object")
+        return "";
+    const { message, cause } = err;
+    if (typeof message === "string")
+        return message;
+    if (cause)
+        return getErrorMessage(cause);
+    return "";
+}
+function isRequestTimeout(err) {
+    if (!err || typeof err !== "object") {
+        return typeof err === "string" && /request timed out/i.test(err);
+    }
+    const { code } = err;
+    return code === -32001 || /request timed out/i.test(getErrorMessage(err));
+}
+function isSessionExpired(err) {
+    return !!(err &&
+        typeof err === "object" &&
+        "code" in err &&
+        err.code === 404);
+}
+function isTransportFailure(err) {
+    if (!err)
+        return false;
+    if (isRequestTimeout(err) || isSessionExpired(err))
+        return false;
+    const message = getErrorMessage(err);
+    if (/(socket hang up|fetch failed|network|connection reset|connection refused|econnrefused|terminated|broken pipe|stream closed|unexpected end|transport)/i
+        .test(message)) {
+        return true;
+    }
+    if (typeof err === "object") {
+        const { name } = err;
+        return name === "TypeError" && message.length > 0;
+    }
+    return false;
+}
+export class GraphitiConnectionManager {
+    constructor(options) {
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestDeadlineMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queueCapacity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "startupTimeoutMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectInitialDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectMaxDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectMultiplier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectJitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connectionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "random", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "setTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "offline"
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connectPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reconnectTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pendingRequests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "readyWaiters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "reconnectDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "flushingQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.endpoint = options.endpoint;
+        this.requestDeadlineMs = options.requestDeadlineMs ?? 15_000;
+        this.queueCapacity = options.queueCapacity ?? 32;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? this.requestDeadlineMs;
+        this.reconnectInitialDelayMs = options.reconnectInitialDelayMs ?? 1_000;
+        this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 60_000;
+        this.reconnectMultiplier = options.reconnectMultiplier ?? 2;
+        this.reconnectJitter = options.reconnectJitter ?? 0.25;
+        this.connectionFactory = options.connectionFactory ?? createMcpConnection;
+        this.random = options.random ?? Math.random;
+        this.setTimerImpl = options.setTimer ??
+            ((callback, delayMs) => setTimeout(callback, delayMs));
+        this.clearTimerImpl = options.clearTimer ??
+            ((timer) => clearTimeout(timer));
+        this.reconnectDelayMs = this.reconnectInitialDelayMs;
+    }
+    getState() {
+        return this.state;
+    }
+    start() {
+        if (this.started || this.state === "closing")
+            return;
+        this.started = true;
+        void this.reconnect();
+    }
+    async stop() {
+        if (this.state === "closing")
+            return;
+        this.started = false;
+        this.state = "closing";
+        this.cancelReconnectTimer();
+        this.rejectAllPending(new GraphitiOfflineError("closing", "Graphiti connection manager stopped"));
+        this.resolveReadyWaiters(false);
+        const connection = this.connection;
+        this.connection = null;
+        if (connection) {
+            try {
+                await connection.close();
+            }
+            catch {
+                // Ignore close errors while shutting down.
+            }
+        }
+    }
+    async ready(timeoutMs = this.startupTimeoutMs) {
+        if (this.state === "connected")
+            return true;
+        if (this.state === "closing")
+            return false;
+        return await new Promise((resolve) => {
+            let settled = false;
+            let timer = null;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer !== null)
+                    this.clearTimerImpl(timer);
+                this.readyWaiters.delete(finish);
+                resolve(value);
+            };
+            this.readyWaiters.add(finish);
+            if (timeoutMs >= 0) {
+                timer = this.setTimerImpl(() => finish(false), timeoutMs);
+            }
+        });
+    }
+    async callTool(name, args, deadlineMs = this.requestDeadlineMs) {
+        const sanitizedArgs = Object.fromEntries(Object.entries(args).filter(([_, value]) => value !== null && value !== undefined));
+        if (this.state === "closing") {
+            throw new GraphitiOfflineError("closing");
+        }
+        if (this.state === "offline") {
+            throw new GraphitiOfflineError("offline");
+        }
+        if (this.state === "connecting") {
+            return await this.enqueueRequest(name, sanitizedArgs, deadlineMs);
+        }
+        return await this.executeConnectedCall(name, sanitizedArgs);
+    }
+    async reconnect() {
+        if (this.state === "closing")
+            return false;
+        if (this.connectPromise)
+            return await this.connectPromise;
+        this.cancelReconnectTimer();
+        this.state = "connecting";
+        const attempt = this.performReconnect();
+        this.connectPromise = attempt.finally(() => {
+            this.connectPromise = null;
+        });
+        return await this.connectPromise;
+    }
+    async performReconnect() {
+        const previousConnection = this.connection;
+        this.connection = null;
+        if (previousConnection) {
+            try {
+                await previousConnection.close();
+            }
+            catch {
+                // Ignore stale close failures during reconnect.
+            }
+        }
+        const nextConnection = this.connectionFactory(this.endpoint);
+        try {
+            await nextConnection.connect();
+            if (this.state === "closing") {
+                try {
+                    await nextConnection.close();
+                }
+                catch {
+                    // Ignore close failures while shutting down.
+                }
+                return false;
+            }
+            this.connection = nextConnection;
+            this.state = "connected";
+            this.reconnectDelayMs = this.reconnectInitialDelayMs;
+            this.resolveReadyWaiters(true);
+            logger.info("Connected to Graphiti MCP server at", this.endpoint);
+            void this.flushPendingQueue();
+            return true;
+        }
+        catch (err) {
+            try {
+                await nextConnection.close();
+            }
+            catch {
+                // Ignore close failures for failed connects.
+            }
+            if (this.state !== "closing") {
+                this.state = "offline";
+                this.rejectAllPending(new GraphitiOfflineError("offline"));
+                this.scheduleReconnect();
+                logger.warn("Failed to connect to Graphiti MCP server", err);
+            }
+            return false;
+        }
+    }
+    async executeConnectedCall(name, args, attempt = 0) {
+        if (this.state !== "connected" || !this.connection) {
+            throw new GraphitiOfflineError("offline");
+        }
+        try {
+            return await this.connection.callTool({ name, arguments: args });
+        }
+        catch (err) {
+            if (isRequestTimeout(err)) {
+                throw new GraphitiRequestTimeoutError(getErrorMessage(err) || undefined);
+            }
+            if (isSessionExpired(err)) {
+                const typedError = new GraphitiSessionExpiredError(getErrorMessage(err) || undefined);
+                if (attempt >= 1) {
+                    void this.reconnect();
+                    throw typedError;
+                }
+                const connected = await this.reconnect();
+                if (!connected)
+                    throw typedError;
+                return await this.executeConnectedCall(name, args, attempt + 1);
+            }
+            if (isTransportFailure(err)) {
+                const typedError = new GraphitiTransportError(getErrorMessage(err) || undefined);
+                if (attempt >= 1) {
+                    void this.reconnect();
+                    throw typedError;
+                }
+                const connected = await this.reconnect();
+                if (!connected)
+                    throw typedError;
+                return await this.executeConnectedCall(name, args, attempt + 1);
+            }
+            throw err;
+        }
+    }
+    enqueueRequest(name, args, deadlineMs) {
+        if (deadlineMs <= 0) {
+            return Promise.reject(new GraphitiQueueTimeoutError());
+        }
+        return new Promise((resolve, reject) => {
+            const pending = {
+                name,
+                args,
+                resolve,
+                reject,
+                timer: null,
+            };
+            pending.timer = this.setTimerImpl(() => {
+                this.removePendingRequest(pending);
+                reject(new GraphitiQueueTimeoutError());
+            }, deadlineMs);
+            if (this.pendingRequests.length >= this.queueCapacity) {
+                const dropped = this.pendingRequests.shift();
+                if (dropped) {
+                    this.clearPendingTimer(dropped);
+                    dropped.reject(new GraphitiQueueTimeoutError("Graphiti request dropped because the connecting queue is full"));
+                }
+            }
+            this.pendingRequests.push(pending);
+        });
+    }
+    async flushPendingQueue() {
+        if (this.flushingQueue || this.state !== "connected")
+            return;
+        this.flushingQueue = true;
+        try {
+            while (this.state === "connected" && this.pendingRequests.length > 0) {
+                const next = this.pendingRequests.shift();
+                if (!next)
+                    continue;
+                this.clearPendingTimer(next);
+                try {
+                    const result = await this.executeConnectedCall(next.name, next.args);
+                    next.resolve(result);
+                }
+                catch (err) {
+                    next.reject(err);
+                }
+            }
+        }
+        finally {
+            this.flushingQueue = false;
+        }
+    }
+    removePendingRequest(target) {
+        const index = this.pendingRequests.indexOf(target);
+        if (index >= 0) {
+            this.pendingRequests.splice(index, 1);
+        }
+        this.clearPendingTimer(target);
+    }
+    clearPendingTimer(request) {
+        if (request.timer !== null) {
+            this.clearTimerImpl(request.timer);
+            request.timer = null;
+        }
+    }
+    rejectAllPending(error) {
+        const pending = [...this.pendingRequests];
+        this.pendingRequests = [];
+        for (const request of pending) {
+            this.clearPendingTimer(request);
+            request.reject(error);
+        }
+    }
+    scheduleReconnect() {
+        if (!this.started || this.state === "closing" || this.reconnectTimer !== null) {
+            return;
+        }
+        const jitterFactor = 1 + ((this.random() * 2) - 1) * this.reconnectJitter;
+        const delayMs = Math.max(0, Math.round(this.reconnectDelayMs * jitterFactor));
+        this.reconnectTimer = this.setTimerImpl(() => {
+            this.reconnectTimer = null;
+            if (this.state === "closing")
+                return;
+            void this.reconnect();
+        }, delayMs);
+        this.reconnectDelayMs = Math.min(this.reconnectMaxDelayMs, Math.max(this.reconnectInitialDelayMs, Math.round(this.reconnectDelayMs * this.reconnectMultiplier)));
+    }
+    cancelReconnectTimer() {
+        if (this.reconnectTimer !== null) {
+            this.clearTimerImpl(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    resolveReadyWaiters(value) {
+        const waiters = [...this.readyWaiters];
+        this.readyWaiters.clear();
+        for (const waiter of waiters) {
+            waiter(value);
+        }
+    }
+}

package/esm/src/services/logger.d.ts

@@ -1,3 +1,5 @@
+export declare const setLoggerDebugOverride: (value: boolean | undefined) => void;
+export declare const setLoggerSilentOverride: (value: boolean) => void;
 export declare const logger: {
     info: (...args: unknown[]) => void;
     warn: (...args: unknown[]) => void;

package/esm/src/services/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/src/services/logger.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM;oBACD,OAAO,EAAE;oBAGT,OAAO,EAAE;qBAGR,OAAO,EAAE;qBAGT,OAAO,EAAE;CAG3B,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/src/services/logger.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,sBAAsB,GAAI,OAAO,OAAO,GAAG,SAAS,KAAG,IAEnE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,IAExD,CAAC;AAEF,eAAO,MAAM,MAAM;oBACD,OAAO,EAAE;oBAIT,OAAO,EAAE;qBAIR,OAAO,EAAE;qBAIT,OAAO,EAAE;CAI3B,CAAC"}

package/esm/src/services/logger.js

@@ -1,19 +1,45 @@
-import process from "node:process";
+import * as dntShim from "../../_dnt.shims.js";
 const console = globalThis.console;
 const PREFIX = "[graphiti]";
+let debugOverride;
+let silentOverride = false;
+const isDebugEnabled = () => {
+    if (debugOverride !== undefined)
+        return debugOverride;
+    try {
+        return !!dntShim.Deno.env.get("GRAPHITI_DEBUG");
+    }
+    catch {
+        return false;
+    }
+};
+export const setLoggerDebugOverride = (value) => {
+    debugOverride = value;
+};
+export const setLoggerSilentOverride = (value) => {
+    silentOverride = value;
+};
 export const logger = {
     info: (...args) => {
-        if (process.env.GRAPHITI_DEBUG)
+        if (silentOverride)
+            return;
+        if (isDebugEnabled())
             console.log(PREFIX, ...args);
     },
     warn: (...args) => {
+        if (silentOverride)
+            return;
         console.warn(PREFIX, ...args);
     },
     error: (...args) => {
+        if (silentOverride)
+            return;
         console.error(PREFIX, ...args);
     },
     debug: (...args) => {
-        if (process.env.GRAPHITI_DEBUG)
+        if (silentOverride)
+            return;
+        if (isDebugEnabled())
             console.debug(PREFIX, ...args);
     },
 };

package/esm/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAW7C;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,EACf,kBAAyB,KACxB,MAKF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,kBAAyB,KACxB,MAMF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,IAAI,GAAG;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAMd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,IAAI,EAAE,KAAG,MACe,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,QAAQ,MAAM,KACb,MAKF,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAkB7C;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,EACf,kBAAyB,KACxB,MAKF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,kBAAyB,KACxB,MAMF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,IAAI,GAAG;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAMd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,IAAI,EAAE,KAAG,MACe,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,QAAQ,MAAM,KACb,MAKF,CAAC"}

package/esm/src/utils.js

@@ -1,7 +1,15 @@
 import os from "node:os";
 import process from "node:process";
 const getProjectName = (directory) => directory.split("/").filter(Boolean).at(-1)?.trim() || "default";
-const getUserName = (home = os.homedir().split("/").filter(Boolean).at(-1)) => home?.trim() || undefined;
+const getHomeDirectory = () => {
+    try {
+        return os.homedir();
+    }
+    catch {
+        return undefined;
+    }
+};
+const getUserName = () => getHomeDirectory()?.split("/").filter(Boolean).at(-1)?.trim() || undefined;
 /**
  * Build a sanitized Graphiti group ID from a prefix and project directory.
  */
@@ -16,7 +24,7 @@ export const makeGroupId = (prefix, directory = process.cwd()) => {
  */
 export const makeUserGroupId = (prefix, directory = process.cwd()) => {
     const projectName = getProjectName(directory);
-    const userName = getUserName();
+    const userName = getUserName() ?? "unknown";
     const prefixPart = prefix ? `${prefix}-` : "";
     const rawGroupId = `${prefixPart}${projectName}__user-${userName}`;
     return rawGroupId.replace(/[^A-Za-z0-9_-]/g, "_");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-graphiti",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "OpenCode plugin for persistent memory via Graphiti knowledge graph",
   "keywords": [
     "opencode",
@@ -49,7 +49,7 @@
     "@opencode-ai/plugin": "^1.1.53",
     "@opencode-ai/sdk": "^1.1.53",
     "cosmiconfig": "9.0.0",
-    "zod": "4.3.6"
+    "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.9.0"