@dbx-tools/appkit-graphiti 0.6.114 → 0.6.115

package/lib/src/plugin.js

@@ -1,16 +1,41 @@
 /**
- * AppKit plugin that supervises Graphiti and a Caddy single-port proxy.
+ * AppKit plugin that supervises Graphiti and republishes user-scoped MCP tools.
  *
  * @module
  */
+import { createHash } from "node:crypto";
 import { createServer } from "node:net";
-import { Plugin, lakebase, toPlugin, } from "@databricks/appkit";
-import { interceptor as appkitInterceptor, plugin as appkitPlugin } from "@dbx-tools/appkit";
-import { exec } from "@dbx-tools/core";
-import { async as asyncModule, log } from "@dbx-tools/shared-core";
-import { MCPClient } from "@mastra/mcp";
+import { ConfigurationError, Plugin, lakebase, toPlugin, } from "@databricks/appkit";
+import { appkit as dbxAppkit, identity as appkitIdentity, plugin as appkitPlugin, } from "@dbx-tools/appkit";
+import { config as coreConfig } from "@dbx-tools/core";
+import { async as asyncModule, log, object } from "@dbx-tools/shared-core";
+import { createTool } from "@mastra/core/tools";
+import { MCPClient, MCPServer } from "@mastra/mcp";
+import concurrently from "concurrently";
 import { GRAPHITI_CONFIG_SCHEMA, resolveGraphitiConfig, } from "./config.js";
 const LAKEBASE_MANIFEST = appkitPlugin.data(lakebase).plugin.manifest;
+const MCP_PATH = "/api/graphiti/mcp";
+const MCP_SERVER_IDLE_MS = 30 * 60 * 1000;
+const MCP_SERVER_SWEEP_MS = 5 * 60 * 1000;
+const SCOPED_TOOL_FIELDS = {
+    add_memory: "group_id",
+    add_triplet: "group_id",
+    build_communities: "group_ids",
+    get_episodes: "group_ids",
+    get_status: undefined,
+    search_memory_facts: "group_ids",
+    search_nodes: "group_ids",
+    summarize_saga: "group_id",
+};
+const WRITE_TOOLS = new Set(["add_memory", "add_triplet", "build_communities", "summarize_saga"]);
+const UNSCOPED_ARGUMENTS = [
+    "center_node_uuid",
+    "previous_episode_uuids",
+    "saga_previous_episode_uuid",
+    "source_node_uuid",
+    "target_node_uuid",
+    "uuid",
+];
 export class GraphitiPlugin extends Plugin {
     static manifest = {
         name: "graphiti",
@@ -31,114 +56,130 @@ export class GraphitiPlugin extends Plugin {
         }));
     }
     logger = log.logger(this);
-    children = [];
+    commands = [];
     mcp;
+    mcpServers = new Map();
+    mcpServerSweep;
     mcpTools = {};
     resolved;
+    setupComplete = false;
+    supervision;
     stopping = false;
     async setup() {
         const configured = resolveGraphitiConfig(this.config);
-        const graphitiPort = configured.graphitiPort || (await availablePort());
-        let litellmPort = configured.litellmPort || (await availablePort());
-        while (litellmPort === graphitiPort)
-            litellmPort = await availablePort();
+        const [graphitiPort, litellmPort, proxyPort] = await distinctPorts(coreConfig.port(undefined, "DATABRICKS_APP_PORT", 8000, coreConfig.ENV_ONLY), configured.graphitiPort, configured.litellmPort, configured.proxyPort);
         this.resolved = {
             ...configured,
             graphitiPort,
             litellmPort,
+            proxyPort,
         };
-        if (!process.env.LAKEBASE_ENDPOINT && !process.env.PGHOST) {
-            throw new Error("Graphiti requires Lakebase; register lakebase() before graphiti() and bind its Postgres resource");
-        }
-        for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-            process.once(signal, () => this.stopGraphiti());
-        }
-        const supervisor = appkitInterceptor.createInterceptorContext({});
-        supervisor.context.onTeardown(() => this.stopGraphiti());
-        const graphiti = exec.spawn(this.resolved.python, ["-m", "dbx_tools.graphiti", "start"], {
-            env: {
-                ...process.env,
-                GRAPHITI_HOST: "127.0.0.1",
-                GRAPHITI_PORT: String(this.resolved.graphitiPort),
-                JOURNAL_NAMESPACE: this.resolved.journalNamespace,
-                LITELLM_HOST: "127.0.0.1",
-                LITELLM_PORT: String(this.resolved.litellmPort),
-                MANAGE_LITELLM: "true",
+        this.supervision = concurrently([
+            {
+                name: "graphiti",
+                command: commandLine([this.resolved.python, "-m", "dbx_tools.graphiti", "start"]),
+                env: {
+                    ...process.env,
+                    GRAPHITI_HOST: "127.0.0.1",
+                    GRAPHITI_PORT: String(this.resolved.graphitiPort),
+                    JOURNAL_NAMESPACE: this.resolved.journalNamespace,
+                    LITELLM_HOST: "127.0.0.1",
+                    LITELLM_PORT: String(this.resolved.litellmPort),
+                    MANAGE_LITELLM: "true",
+                },
+            },
+            {
+                name: "caddy",
+                command: commandLine([
+                    this.resolved.python,
+                    "-m",
+                    "dbx_tools.graphiti.proxy",
+                    "--proxy-port",
+                    String(this.resolved.proxyPort),
+                    "--graphiti-port",
+                    String(this.resolved.graphitiPort),
+                ]),
+                env: process.env,
             },
-            stdin: "ignore",
-            stdout: "inherit",
-            stderr: "inherit",
-        });
-        const caddy = exec.spawn(this.resolved.python, [
-            "-m",
-            "dbx_tools.graphiti.proxy",
-            "--public-port",
-            String(this.resolved.publicPort),
-            "--app-port",
-            String(this.resolved.appPort),
-            "--graphiti-port",
-            String(this.resolved.graphitiPort),
-            "--route-prefix",
-            this.resolved.routePrefix,
         ], {
-            env: process.env,
-            stdin: "ignore",
-            stdout: "inherit",
-            stderr: "inherit",
+            killOthersOn: ["failure", "success"],
+            killSignal: "SIGTERM",
+            killTimeout: 12_000,
+            prefix: "name",
+            prefixColors: false,
         });
-        this.children = [graphiti, caddy];
-        for (const child of this.children)
-            supervisor.context.bindProcess(child);
-        await waitForGraphiti(this.resolved.graphitiPort);
-        this.mcp = new MCPClient({
-            id: `appkit-graphiti-${this.resolved.graphitiPort}`,
-            servers: {
-                graphiti: {
-                    url: new URL(`http://127.0.0.1:${this.resolved.graphitiPort}/mcp`),
-                },
-            },
+        this.commands = this.supervision.commands;
+        void this.supervision.result.then(() => this.onSupervisorExit(), (error) => this.onSupervisorExit(error));
+        const supervisionFailure = this.supervision.result.then(() => {
+            throw new Error("Graphiti sidecar supervisor exited during startup");
+        }, (error) => {
+            throw error;
         });
-        const discovered = await this.mcp.listTools();
-        this.mcpTools = Object.fromEntries(Object.entries(discovered).map(([name, tool]) => [
-            name.replace(/^graphiti_/, ""),
-            tool,
-        ]));
+        try {
+            await Promise.race([
+                (async () => {
+                    await waitForGraphiti(graphitiPort);
+                    await waitForGraphiti(proxyPort);
+                })(),
+                supervisionFailure,
+            ]);
+            this.mcp = new MCPClient({
+                id: `appkit-graphiti-${this.resolved.graphitiPort}`,
+                servers: {
+                    graphiti: {
+                        url: new URL(`http://127.0.0.1:${this.resolved.proxyPort}/mcp`),
+                    },
+                },
+            });
+            const discovered = await this.mcp.listTools();
+            this.mcpTools = Object.fromEntries(Object.entries(discovered)
+                .map(([name, tool]) => [name.replace(/^graphiti_/, ""), tool])
+                .filter(([name]) => name in SCOPED_TOOL_FIELDS));
+            const missing = Object.keys(SCOPED_TOOL_FIELDS).filter((name) => !this.mcpTools[name]);
+            if (missing.length > 0) {
+                throw new Error(`Graphiti did not publish required scoped tools: ${missing.join(", ")}`);
+            }
+        }
+        catch (error) {
+            await this.stopSidecars();
+            throw error;
+        }
+        this.setupComplete = true;
+        this.mcpServerSweep = setInterval(() => this.closeIdleMcpServers(), MCP_SERVER_SWEEP_MS);
+        this.mcpServerSweep.unref();
         this.logger.info("ready", {
-            appPort: this.resolved.appPort,
             graphitiPort: this.resolved.graphitiPort,
             litellmPort: this.resolved.litellmPort,
-            publicPort: this.resolved.publicPort,
-            mcpPath: `${this.resolved.routePrefix}/mcp/`,
+            proxyPort: this.resolved.proxyPort,
+            mcpPath: MCP_PATH,
             tools: Object.keys(this.mcpTools),
         });
     }
+    injectRoutes(router) {
+        for (const method of ["get", "post", "delete"]) {
+            this.route(router, {
+                name: `${method}Mcp`,
+                method,
+                path: "/mcp",
+                handler: (request, response) => this.forwardMcp(request, response),
+            });
+        }
+    }
     abortActiveOperations() {
         super.abortActiveOperations();
-        this.stopGraphiti();
         void this.mcp?.disconnect();
-        this.mcp = undefined;
-        this.mcpTools = {};
-        for (const child of this.children) {
-            if (!child.killed)
-                child.kill("SIGTERM");
-        }
-        this.children = [];
+    }
+    async shutdown() {
+        await this.stopSidecars();
     }
     exports() {
-        const resolved = this.resolved ?? resolveGraphitiConfig(this.config);
-        return {
-            appPort: resolved.appPort,
-            graphitiPort: resolved.graphitiPort,
-            litellmPort: resolved.litellmPort,
-            mcpPath: `${resolved.routePrefix}/mcp/`,
-            publicPort: resolved.publicPort,
-            routePrefix: resolved.routePrefix,
-        };
+        return { mcpPath: MCP_PATH };
     }
     toolkit() {
         return Object.fromEntries(Object.entries(this.mcpTools).map(([name, tool]) => [
             name,
             {
+                __toolkitRef: true,
                 pluginName: "graphiti",
                 localName: name,
                 def: {
@@ -146,28 +187,124 @@ export class GraphitiPlugin extends Plugin {
                     description: tool.description,
                     parameters: tool.inputSchema ?? { type: "object", properties: {} },
                 },
+                annotations: {
+                    effect: WRITE_TOOLS.has(name) ? "write" : "read",
+                    requiresUserContext: true,
+                },
             },
         ]));
     }
-    async executeAgentTool(name, args, signal) {
+    async executeAgentTool(name, args, signal, context) {
         const tool = this.mcpTools[name];
         if (!tool?.execute)
             throw new Error(`Unknown Graphiti tool: ${name}`);
-        return tool.execute(args, { abortSignal: signal });
+        const userId = context?.resourceId ?? executionContextUserId();
+        return tool.execute(scopedArguments(name, args, userScope(userId)), {
+            abortSignal: signal,
+        });
     }
-    stopGraphiti() {
-        if (this.stopping || !this.resolved)
+    async forwardMcp(request, response) {
+        if (!this.resolved) {
+            response.status(503).json({ error: "Graphiti is not ready" });
             return;
-        this.stopping = true;
-        void exec.spawn(this.resolved.python, ["-m", "dbx_tools.graphiti", "down"], {
-            env: process.env,
-            stdin: "ignore",
-            stdout: "inherit",
-            stderr: "inherit",
+        }
+        const userId = appkitIdentity.requestUserId(request) ?? executionContextUserId();
+        const server = this.mcpServer(userId);
+        await server.startHTTP({
+            url: new URL(request.originalUrl, "http://app.local"),
+            httpPath: MCP_PATH,
+            req: request,
+            res: response,
+        });
+    }
+    mcpServer(userId) {
+        const existing = this.mcpServers.get(userId);
+        if (existing) {
+            existing.lastUsed = Date.now();
+            return existing.server;
+        }
+        const scope = userScope(userId);
+        const tools = Object.fromEntries(Object.entries(this.mcpTools).map(([name, tool]) => [
+            name,
+            createTool({
+                id: name,
+                description: tool.description ?? name,
+                ...(tool.inputSchema ? { inputSchema: tool.inputSchema } : {}),
+                execute: (args, context) => {
+                    if (!tool.execute)
+                        throw new Error(`Graphiti tool cannot execute: ${name}`);
+                    return tool.execute(scopedArguments(name, args, scope), context);
+                },
+            }),
+        ]));
+        const server = new MCPServer({
+            name: "Graphiti",
+            version: "1.0.0",
+            tools,
         });
+        this.mcpServers.set(userId, { lastUsed: Date.now(), server });
+        return server;
+    }
+    onSupervisorExit(error) {
+        if (this.stopping || !this.setupComplete)
+            return;
+        this.logger.error("sidecar supervisor exited", { error });
+        process.kill(process.pid, "SIGTERM");
+    }
+    async stopSidecars() {
+        if (this.stopping)
+            return;
+        this.stopping = true;
+        if (this.mcpServerSweep)
+            clearInterval(this.mcpServerSweep);
+        this.mcpServerSweep = undefined;
+        await Promise.allSettled([...this.mcpServers.values()].map(({ server }) => server.close()));
+        this.mcpServers.clear();
+        await this.mcp?.disconnect();
+        this.mcp = undefined;
+        this.mcpTools = {};
+        for (const command of this.commands)
+            command.kill("SIGTERM");
+        if (this.supervision)
+            await this.supervision.result.catch(() => undefined);
+        this.commands = [];
+        this.supervision = undefined;
+    }
+    closeIdleMcpServers() {
+        const cutoff = Date.now() - MCP_SERVER_IDLE_MS;
+        for (const [userId, entry] of this.mcpServers) {
+            if (entry.lastUsed >= cutoff)
+                continue;
+            this.mcpServers.delete(userId);
+            void entry.server.close().catch((error) => {
+                this.logger.warn("idle MCP server close failed", { error });
+            });
+        }
     }
 }
 export const graphiti = toPlugin(GraphitiPlugin);
+function executionContextUserId() {
+    const context = dbxAppkit.tryGetExecutionContext();
+    if (!context)
+        throw new Error("Graphiti memory requires an AppKit execution context");
+    return "userId" in context ? context.userId : context.serviceUserId;
+}
+function userScope(userId) {
+    return `user_${createHash("sha256").update(userId).digest("base64url")}`;
+}
+function scopedArguments(name, args, scope) {
+    if (!(name in SCOPED_TOOL_FIELDS))
+        throw new Error(`Graphiti tool is not user-scoped: ${name}`);
+    const scoped = object.isRecord(args) ? { ...args } : {};
+    for (const argument of UNSCOPED_ARGUMENTS)
+        delete scoped[argument];
+    const field = SCOPED_TOOL_FIELDS[name];
+    if (field === "group_id")
+        scoped.group_id = scope;
+    if (field === "group_ids")
+        scoped.group_ids = [scope];
+    return scoped;
+}
 async function waitForGraphiti(port) {
     for await (const ready of asyncModule.poll(async ({ signal }) => {
         try {
@@ -201,4 +338,20 @@ async function availablePort() {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin that supervises Graphiti and a Caddy single-port proxy.\n *\n * @module\n */\nimport { createServer } from \"node:net\";\nimport {\n  Plugin,\n  lakebase,\n  toPlugin,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport { interceptor as appkitInterceptor, plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport { exec } from \"@dbx-tools/core\";\nimport { async as asyncModule, log } from \"@dbx-tools/shared-core\";\nimport type { Tool } from \"@mastra/core/tools\";\nimport { MCPClient } from \"@mastra/mcp\";\nimport {\n  GRAPHITI_CONFIG_SCHEMA,\n  resolveGraphitiConfig,\n  type GraphitiPluginConfig,\n  type ResolvedGraphitiPluginConfig,\n} from \"./config.ts\";\n\nconst LAKEBASE_MANIFEST = appkitPlugin.data(lakebase).plugin.manifest;\n\ninterface ToolkitEntry {\n  pluginName: string;\n  localName: string;\n  def: {\n    name: string;\n    description: string;\n    parameters: unknown;\n  };\n}\n\nexport class GraphitiPlugin extends Plugin<GraphitiPluginConfig> {\n  static manifest: PluginManifest<\"graphiti\"> = {\n    name: \"graphiti\",\n    displayName: \"Graphiti\",\n    description:\n      \"Runs the dbx-tools Graphiti MCP sidecar with Lakebase-backed recovery and \" +\n      \"publishes it through the App's single port with Caddy.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [...LAKEBASE_MANIFEST.resources.required],\n    },\n    config: { schema: GRAPHITI_CONFIG_SCHEMA },\n  };\n\n  static getResourceRequirements(): ResourceRequirement[] {\n    return LAKEBASE_MANIFEST.resources.required.map((resource) => ({\n      ...resource,\n      required: true,\n    }));\n  }\n\n  private readonly logger = log.logger(this);\n  private children: ReturnType<typeof exec.spawn>[] = [];\n  private mcp?: MCPClient;\n  private mcpTools: Record<string, Tool> = {};\n  private resolved?: ResolvedGraphitiPluginConfig;\n  private stopping = false;\n\n  override async setup(): Promise<void> {\n    const configured = resolveGraphitiConfig(this.config);\n    const graphitiPort = configured.graphitiPort || (await availablePort());\n    let litellmPort = configured.litellmPort || (await availablePort());\n    while (litellmPort === graphitiPort) litellmPort = await availablePort();\n    this.resolved = {\n      ...configured,\n      graphitiPort,\n      litellmPort,\n    };\n    if (!process.env.LAKEBASE_ENDPOINT && !process.env.PGHOST) {\n      throw new Error(\n        \"Graphiti requires Lakebase; register lakebase() before graphiti() and bind its Postgres resource\",\n      );\n    }\n    for (const signal of [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const) {\n      process.once(signal, () => this.stopGraphiti());\n    }\n    const supervisor = appkitInterceptor.createInterceptorContext({});\n    supervisor.context.onTeardown(() => this.stopGraphiti());\n    const graphiti = exec.spawn(this.resolved.python, [\"-m\", \"dbx_tools.graphiti\", \"start\"], {\n      env: {\n        ...process.env,\n        GRAPHITI_HOST: \"127.0.0.1\",\n        GRAPHITI_PORT: String(this.resolved.graphitiPort),\n        JOURNAL_NAMESPACE: this.resolved.journalNamespace,\n        LITELLM_HOST: \"127.0.0.1\",\n        LITELLM_PORT: String(this.resolved.litellmPort),\n        MANAGE_LITELLM: \"true\",\n      },\n      stdin: \"ignore\",\n      stdout: \"inherit\",\n      stderr: \"inherit\",\n    });\n    const caddy = exec.spawn(\n      this.resolved.python,\n      [\n        \"-m\",\n        \"dbx_tools.graphiti.proxy\",\n        \"--public-port\",\n        String(this.resolved.publicPort),\n        \"--app-port\",\n        String(this.resolved.appPort),\n        \"--graphiti-port\",\n        String(this.resolved.graphitiPort),\n        \"--route-prefix\",\n        this.resolved.routePrefix,\n      ],\n      {\n        env: process.env,\n        stdin: \"ignore\",\n        stdout: \"inherit\",\n        stderr: \"inherit\",\n      },\n    );\n    this.children = [graphiti, caddy];\n    for (const child of this.children) supervisor.context.bindProcess(child);\n    await waitForGraphiti(this.resolved.graphitiPort);\n    this.mcp = new MCPClient({\n      id: `appkit-graphiti-${this.resolved.graphitiPort}`,\n      servers: {\n        graphiti: {\n          url: new URL(`http://127.0.0.1:${this.resolved.graphitiPort}/mcp`),\n        },\n      },\n    });\n    const discovered = await this.mcp.listTools();\n    this.mcpTools = Object.fromEntries(\n      Object.entries(discovered).map(([name, tool]) => [\n        name.replace(/^graphiti_/, \"\"),\n        tool as Tool,\n      ]),\n    );\n    this.logger.info(\"ready\", {\n      appPort: this.resolved.appPort,\n      graphitiPort: this.resolved.graphitiPort,\n      litellmPort: this.resolved.litellmPort,\n      publicPort: this.resolved.publicPort,\n      mcpPath: `${this.resolved.routePrefix}/mcp/`,\n      tools: Object.keys(this.mcpTools),\n    });\n  }\n\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    this.stopGraphiti();\n    void this.mcp?.disconnect();\n    this.mcp = undefined;\n    this.mcpTools = {};\n    for (const child of this.children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    this.children = [];\n  }\n\n  override exports() {\n    const resolved = this.resolved ?? resolveGraphitiConfig(this.config);\n    return {\n      appPort: resolved.appPort,\n      graphitiPort: resolved.graphitiPort,\n      litellmPort: resolved.litellmPort,\n      mcpPath: `${resolved.routePrefix}/mcp/`,\n      publicPort: resolved.publicPort,\n      routePrefix: resolved.routePrefix,\n    };\n  }\n\n  toolkit(): Record<string, ToolkitEntry> {\n    return Object.fromEntries(\n      Object.entries(this.mcpTools).map(([name, tool]) => [\n        name,\n        {\n          pluginName: \"graphiti\",\n          localName: name,\n          def: {\n            name,\n            description: tool.description,\n            parameters: tool.inputSchema ?? { type: \"object\", properties: {} },\n          },\n        },\n      ]),\n    );\n  }\n\n  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {\n    const tool = this.mcpTools[name];\n    if (!tool?.execute) throw new Error(`Unknown Graphiti tool: ${name}`);\n    return tool.execute(args, { abortSignal: signal } as never);\n  }\n\n  private stopGraphiti(): void {\n    if (this.stopping || !this.resolved) return;\n    this.stopping = true;\n    void exec.spawn(this.resolved.python, [\"-m\", \"dbx_tools.graphiti\", \"down\"], {\n      env: process.env,\n      stdin: \"ignore\",\n      stdout: \"inherit\",\n      stderr: \"inherit\",\n    });\n  }\n}\n\nexport const graphiti = toPlugin(GraphitiPlugin);\n\nasync function waitForGraphiti(port: number): Promise<void> {\n  for await (const ready of asyncModule.poll(\n    async ({ signal }) => {\n      try {\n        const response = await fetch(`http://127.0.0.1:${port}/health`, { signal });\n        return response.ok;\n      } catch {\n        return false;\n      }\n    },\n    {\n      intervalMs: 250,\n      timeoutMs: 60_000,\n      predicate: (ready) => !ready,\n    },\n  )) {\n    if (ready) return;\n  }\n}\n\nasync function availablePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once(\"error\", reject);\n    server.listen(0, \"127.0.0.1\", () => {\n      const address = server.address();\n      if (!address || typeof address === \"string\") {\n        server.close();\n        reject(new Error(\"Could not allocate a Graphiti loopback port\"));\n        return;\n      }\n      server.close((error) => (error ? reject(error) : resolve(address.port)));\n    });\n  });\n}\n"]}
+async function distinctPorts(appPort, graphitiPort, litellmPort, proxyPort) {
+    const ports = [appPort];
+    for (const configuredPort of [graphitiPort, litellmPort, proxyPort]) {
+        if (configuredPort && ports.includes(configuredPort)) {
+            throw new ConfigurationError("Graphiti sidecar ports must differ from DATABRICKS_APP_PORT");
+        }
+        let port = configuredPort || (await availablePort());
+        while (ports.includes(port))
+            port = await availablePort();
+        ports.push(port);
+    }
+    return ports.slice(1);
+}
+function commandLine(arguments_) {
+    return arguments_.map((value) => `'${value.replaceAll("'", "'\\''")}'`).join(" ");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit plugin that supervises Graphiti and republishes user-scoped MCP tools.\n *\n * @module\n */\nimport { createHash } from \"node:crypto\";\nimport { createServer } from \"node:net\";\nimport {\n  ConfigurationError,\n  Plugin,\n  lakebase,\n  toPlugin,\n  type IAppRouter,\n  type PluginManifest,\n  type ResourceRequirement,\n} from \"@databricks/appkit\";\nimport {\n  appkit as dbxAppkit,\n  identity as appkitIdentity,\n  plugin as appkitPlugin,\n} from \"@dbx-tools/appkit\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport { async as asyncModule, log, object } from \"@dbx-tools/shared-core\";\nimport { createTool, type Tool } from \"@mastra/core/tools\";\nimport { MCPClient, MCPServer } from \"@mastra/mcp\";\nimport concurrently, { type Command, type ConcurrentlyResult } from \"concurrently\";\nimport type express from \"express\";\nimport {\n  GRAPHITI_CONFIG_SCHEMA,\n  resolveGraphitiConfig,\n  type GraphitiPluginConfig,\n  type ResolvedGraphitiPluginConfig,\n} from \"./config.ts\";\n\nconst LAKEBASE_MANIFEST = appkitPlugin.data(lakebase).plugin.manifest;\nconst MCP_PATH = \"/api/graphiti/mcp\";\nconst MCP_SERVER_IDLE_MS = 30 * 60 * 1000;\nconst MCP_SERVER_SWEEP_MS = 5 * 60 * 1000;\nconst SCOPED_TOOL_FIELDS = {\n  add_memory: \"group_id\",\n  add_triplet: \"group_id\",\n  build_communities: \"group_ids\",\n  get_episodes: \"group_ids\",\n  get_status: undefined,\n  search_memory_facts: \"group_ids\",\n  search_nodes: \"group_ids\",\n  summarize_saga: \"group_id\",\n} as const;\nconst WRITE_TOOLS = new Set([\"add_memory\", \"add_triplet\", \"build_communities\", \"summarize_saga\"]);\nconst UNSCOPED_ARGUMENTS = [\n  \"center_node_uuid\",\n  \"previous_episode_uuids\",\n  \"saga_previous_episode_uuid\",\n  \"source_node_uuid\",\n  \"target_node_uuid\",\n  \"uuid\",\n] as const;\n\ninterface ToolkitEntry {\n  readonly __toolkitRef: true;\n  pluginName: string;\n  localName: string;\n  def: {\n    name: string;\n    description: string;\n    parameters: unknown;\n  };\n  annotations: {\n    effect: \"read\" | \"write\";\n    requiresUserContext: true;\n  };\n}\n\ninterface UserMcpServer {\n  lastUsed: number;\n  server: MCPServer;\n}\n\nexport class GraphitiPlugin extends Plugin<GraphitiPluginConfig> {\n  static manifest: PluginManifest<\"graphiti\"> = {\n    name: \"graphiti\",\n    displayName: \"Graphiti\",\n    description:\n      \"Runs the dbx-tools Graphiti MCP sidecar with Lakebase-backed recovery and \" +\n      \"publishes it through the App's single port with Caddy.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [...LAKEBASE_MANIFEST.resources.required],\n    },\n    config: { schema: GRAPHITI_CONFIG_SCHEMA },\n  };\n\n  static getResourceRequirements(): ResourceRequirement[] {\n    return LAKEBASE_MANIFEST.resources.required.map((resource) => ({\n      ...resource,\n      required: true,\n    }));\n  }\n\n  private readonly logger = log.logger(this);\n  private commands: Command[] = [];\n  private mcp?: MCPClient;\n  private mcpServers = new Map<string, UserMcpServer>();\n  private mcpServerSweep?: NodeJS.Timeout;\n  private mcpTools: Record<string, Tool> = {};\n  private resolved?: ResolvedGraphitiPluginConfig;\n  private setupComplete = false;\n  private supervision?: ConcurrentlyResult;\n  private stopping = false;\n\n  override async setup(): Promise<void> {\n    const configured = resolveGraphitiConfig(this.config);\n    const [graphitiPort, litellmPort, proxyPort] = await distinctPorts(\n      coreConfig.port(undefined, \"DATABRICKS_APP_PORT\", 8000, coreConfig.ENV_ONLY),\n      configured.graphitiPort,\n      configured.litellmPort,\n      configured.proxyPort,\n    );\n    this.resolved = {\n      ...configured,\n      graphitiPort,\n      litellmPort,\n      proxyPort,\n    };\n    this.supervision = concurrently(\n      [\n        {\n          name: \"graphiti\",\n          command: commandLine([this.resolved.python, \"-m\", \"dbx_tools.graphiti\", \"start\"]),\n          env: {\n            ...process.env,\n            GRAPHITI_HOST: \"127.0.0.1\",\n            GRAPHITI_PORT: String(this.resolved.graphitiPort),\n            JOURNAL_NAMESPACE: this.resolved.journalNamespace,\n            LITELLM_HOST: \"127.0.0.1\",\n            LITELLM_PORT: String(this.resolved.litellmPort),\n            MANAGE_LITELLM: \"true\",\n          },\n        },\n        {\n          name: \"caddy\",\n          command: commandLine([\n            this.resolved.python,\n            \"-m\",\n            \"dbx_tools.graphiti.proxy\",\n            \"--proxy-port\",\n            String(this.resolved.proxyPort),\n            \"--graphiti-port\",\n            String(this.resolved.graphitiPort),\n          ]),\n          env: process.env,\n        },\n      ],\n      {\n        killOthersOn: [\"failure\", \"success\"],\n        killSignal: \"SIGTERM\",\n        killTimeout: 12_000,\n        prefix: \"name\",\n        prefixColors: false,\n      },\n    );\n    this.commands = this.supervision.commands;\n    void this.supervision.result.then(\n      () => this.onSupervisorExit(),\n      (error) => this.onSupervisorExit(error),\n    );\n    const supervisionFailure = this.supervision.result.then(\n      () => {\n        throw new Error(\"Graphiti sidecar supervisor exited during startup\");\n      },\n      (error) => {\n        throw error;\n      },\n    );\n    try {\n      await Promise.race([\n        (async () => {\n          await waitForGraphiti(graphitiPort);\n          await waitForGraphiti(proxyPort);\n        })(),\n        supervisionFailure,\n      ]);\n      this.mcp = new MCPClient({\n        id: `appkit-graphiti-${this.resolved.graphitiPort}`,\n        servers: {\n          graphiti: {\n            url: new URL(`http://127.0.0.1:${this.resolved.proxyPort}/mcp`),\n          },\n        },\n      });\n      const discovered = await this.mcp.listTools();\n      this.mcpTools = Object.fromEntries(\n        Object.entries(discovered)\n          .map(([name, tool]) => [name.replace(/^graphiti_/, \"\"), tool as Tool] as const)\n          .filter(([name]) => name in SCOPED_TOOL_FIELDS),\n      );\n      const missing = Object.keys(SCOPED_TOOL_FIELDS).filter((name) => !this.mcpTools[name]);\n      if (missing.length > 0) {\n        throw new Error(`Graphiti did not publish required scoped tools: ${missing.join(\", \")}`);\n      }\n    } catch (error) {\n      await this.stopSidecars();\n      throw error;\n    }\n    this.setupComplete = true;\n    this.mcpServerSweep = setInterval(() => this.closeIdleMcpServers(), MCP_SERVER_SWEEP_MS);\n    this.mcpServerSweep.unref();\n    this.logger.info(\"ready\", {\n      graphitiPort: this.resolved.graphitiPort,\n      litellmPort: this.resolved.litellmPort,\n      proxyPort: this.resolved.proxyPort,\n      mcpPath: MCP_PATH,\n      tools: Object.keys(this.mcpTools),\n    });\n  }\n\n  override injectRoutes(router: IAppRouter): void {\n    for (const method of [\"get\", \"post\", \"delete\"] as const) {\n      this.route(router, {\n        name: `${method}Mcp`,\n        method,\n        path: \"/mcp\",\n        handler: (request, response) => this.forwardMcp(request, response),\n      });\n    }\n  }\n\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    void this.mcp?.disconnect();\n  }\n\n  async shutdown(): Promise<void> {\n    await this.stopSidecars();\n  }\n\n  override exports() {\n    return { mcpPath: MCP_PATH };\n  }\n\n  toolkit(): Record<string, ToolkitEntry> {\n    return Object.fromEntries(\n      Object.entries(this.mcpTools).map(([name, tool]) => [\n        name,\n        {\n          __toolkitRef: true as const,\n          pluginName: \"graphiti\",\n          localName: name,\n          def: {\n            name,\n            description: tool.description,\n            parameters: tool.inputSchema ?? { type: \"object\", properties: {} },\n          },\n          annotations: {\n            effect: WRITE_TOOLS.has(name) ? (\"write\" as const) : (\"read\" as const),\n            requiresUserContext: true as const,\n          },\n        },\n      ]),\n    );\n  }\n\n  async executeAgentTool(\n    name: string,\n    args: unknown,\n    signal?: AbortSignal,\n    context?: { resourceId?: string },\n  ): Promise<unknown> {\n    const tool = this.mcpTools[name];\n    if (!tool?.execute) throw new Error(`Unknown Graphiti tool: ${name}`);\n    const userId = context?.resourceId ?? executionContextUserId();\n    return tool.execute(scopedArguments(name, args, userScope(userId)), {\n      abortSignal: signal,\n    } as never);\n  }\n\n  private async forwardMcp(request: express.Request, response: express.Response): Promise<void> {\n    if (!this.resolved) {\n      response.status(503).json({ error: \"Graphiti is not ready\" });\n      return;\n    }\n    const userId = appkitIdentity.requestUserId(request) ?? executionContextUserId();\n    const server = this.mcpServer(userId);\n    await server.startHTTP({\n      url: new URL(request.originalUrl, \"http://app.local\"),\n      httpPath: MCP_PATH,\n      req: request,\n      res: response,\n    });\n  }\n\n  private mcpServer(userId: string): MCPServer {\n    const existing = this.mcpServers.get(userId);\n    if (existing) {\n      existing.lastUsed = Date.now();\n      return existing.server;\n    }\n    const scope = userScope(userId);\n    const tools = Object.fromEntries(\n      Object.entries(this.mcpTools).map(([name, tool]) => [\n        name,\n        createTool({\n          id: name,\n          description: tool.description ?? name,\n          ...(tool.inputSchema ? { inputSchema: tool.inputSchema as never } : {}),\n          execute: (args: unknown, context: unknown) => {\n            if (!tool.execute) throw new Error(`Graphiti tool cannot execute: ${name}`);\n            return tool.execute(scopedArguments(name, args, scope), context as never);\n          },\n        }),\n      ]),\n    );\n    const server = new MCPServer({\n      name: \"Graphiti\",\n      version: \"1.0.0\",\n      tools,\n    });\n    this.mcpServers.set(userId, { lastUsed: Date.now(), server });\n    return server;\n  }\n\n  private onSupervisorExit(error?: unknown): void {\n    if (this.stopping || !this.setupComplete) return;\n    this.logger.error(\"sidecar supervisor exited\", { error });\n    process.kill(process.pid, \"SIGTERM\");\n  }\n\n  private async stopSidecars(): Promise<void> {\n    if (this.stopping) return;\n    this.stopping = true;\n    if (this.mcpServerSweep) clearInterval(this.mcpServerSweep);\n    this.mcpServerSweep = undefined;\n    await Promise.allSettled([...this.mcpServers.values()].map(({ server }) => server.close()));\n    this.mcpServers.clear();\n    await this.mcp?.disconnect();\n    this.mcp = undefined;\n    this.mcpTools = {};\n    for (const command of this.commands) command.kill(\"SIGTERM\");\n    if (this.supervision) await this.supervision.result.catch(() => undefined);\n    this.commands = [];\n    this.supervision = undefined;\n  }\n\n  private closeIdleMcpServers(): void {\n    const cutoff = Date.now() - MCP_SERVER_IDLE_MS;\n    for (const [userId, entry] of this.mcpServers) {\n      if (entry.lastUsed >= cutoff) continue;\n      this.mcpServers.delete(userId);\n      void entry.server.close().catch((error) => {\n        this.logger.warn(\"idle MCP server close failed\", { error });\n      });\n    }\n  }\n}\n\nexport const graphiti = toPlugin(GraphitiPlugin);\n\nfunction executionContextUserId(): string {\n  const context = dbxAppkit.tryGetExecutionContext();\n  if (!context) throw new Error(\"Graphiti memory requires an AppKit execution context\");\n  return \"userId\" in context ? context.userId : context.serviceUserId;\n}\n\nfunction userScope(userId: string): string {\n  return `user_${createHash(\"sha256\").update(userId).digest(\"base64url\")}`;\n}\n\nfunction scopedArguments(name: string, args: unknown, scope: string): Record<string, unknown> {\n  if (!(name in SCOPED_TOOL_FIELDS)) throw new Error(`Graphiti tool is not user-scoped: ${name}`);\n  const scoped = object.isRecord(args) ? { ...args } : {};\n  for (const argument of UNSCOPED_ARGUMENTS) delete scoped[argument];\n  const field = SCOPED_TOOL_FIELDS[name as keyof typeof SCOPED_TOOL_FIELDS];\n  if (field === \"group_id\") scoped.group_id = scope;\n  if (field === \"group_ids\") scoped.group_ids = [scope];\n  return scoped;\n}\n\nasync function waitForGraphiti(port: number): Promise<void> {\n  for await (const ready of asyncModule.poll(\n    async ({ signal }) => {\n      try {\n        const response = await fetch(`http://127.0.0.1:${port}/health`, { signal });\n        return response.ok;\n      } catch {\n        return false;\n      }\n    },\n    {\n      intervalMs: 250,\n      timeoutMs: 60_000,\n      predicate: (ready) => !ready,\n    },\n  )) {\n    if (ready) return;\n  }\n}\n\nasync function availablePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once(\"error\", reject);\n    server.listen(0, \"127.0.0.1\", () => {\n      const address = server.address();\n      if (!address || typeof address === \"string\") {\n        server.close();\n        reject(new Error(\"Could not allocate a Graphiti loopback port\"));\n        return;\n      }\n      server.close((error) => (error ? reject(error) : resolve(address.port)));\n    });\n  });\n}\n\nasync function distinctPorts(\n  appPort: number,\n  graphitiPort: number,\n  litellmPort: number,\n  proxyPort: number,\n): Promise<[number, number, number]> {\n  const ports = [appPort];\n  for (const configuredPort of [graphitiPort, litellmPort, proxyPort]) {\n    if (configuredPort && ports.includes(configuredPort)) {\n      throw new ConfigurationError(\"Graphiti sidecar ports must differ from DATABRICKS_APP_PORT\");\n    }\n    let port = configuredPort || (await availablePort());\n    while (ports.includes(port)) port = await availablePort();\n    ports.push(port);\n  }\n  return ports.slice(1) as [number, number, number];\n}\n\nfunction commandLine(arguments_: string[]): string {\n  return arguments_.map((value) => `'${value.replaceAll(\"'\", \"'\\\\''\")}'`).join(\" \");\n}\n"]}

package/package.json

@@ -19,17 +19,19 @@
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",
+    "@types/express": "^5.0.5",
     "@types/json-schema": "^7",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.114",
-    "@dbx-tools/core": "0.6.114",
-    "@dbx-tools/shared-core": "0.6.114",
+    "@dbx-tools/appkit": "0.6.115",
+    "@dbx-tools/core": "0.6.115",
+    "@dbx-tools/shared-core": "0.6.115",
     "@mastra/core": "1.47.0",
-    "@mastra/mcp": "1.12.0"
+    "@mastra/mcp": "1.12.0",
+    "concurrently": "^10.0.3"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -45,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.114",
+  "version": "0.6.115",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {