@dbx-tools/appkit-graphiti 0.6.113

package/README.md

@@ -0,0 +1,77 @@
+# `@dbx-tools/appkit-graphiti`
+
+AppKit process plugin for the Python `dbx-tools-graphiti` MCP runtime.
+
+## Key features
+
+- starts Graphiti as a supervised AppKit sidecar;
+- inherits the Lakebase environment resolved by `@dbx-tools/appkit` and native
+  `lakebase()`, enabling the Python Postgres write journal automatically;
+- starts mise-managed Caddy on `DATABRICKS_APP_PORT`;
+- routes `/graphiti/*` to Graphiti and all other traffic to AppKit;
+- selects a free loopback port for Graphiti unless one is explicitly configured;
+- discovers the upstream MCP tools and exposes them through
+  `plugins.graphiti?.toolkit()` for Mastra and AppKit agents;
+- binds both child processes to the shared concurrently-style supervisor so
+  signals propagate and any child exit tears down the app;
+- exposes the internal AppKit port and public MCP path through plugin exports.
+
+## Why use this over native AppKit
+
+AppKit has no Graphiti or embedded MCP sidecar. This package owns AppKit process
+lifecycle and single-port routing while `dbx-tools-graphiti` owns
+Graphiti, Neo4j, LiteLLM, and Postgres recovery.
+
+## Register
+
+Install `dbx-tools-graphiti` in the app's Python dependencies, then register
+native `lakebase()` before the Graphiti plugin:
+
+```ts
+import { lakebase, server } from "@databricks/appkit";
+import { appkit } from "@dbx-tools/appkit";
+import { config as graphitiConfig, plugin as graphitiPlugin } from "@dbx-tools/appkit-graphiti";
+
+const graphiti = graphitiConfig.resolveGraphitiConfig();
+
+await appkit.createApp({
+  plugins: [
+    server({ host: "127.0.0.1", port: graphiti.appPort }),
+    lakebase(),
+    graphitiPlugin.graphiti(graphiti),
+  ],
+});
+```
+
+The public MCP endpoint is `/graphiti/mcp/`. Caddy listens on the platform's
+`DATABRICKS_APP_PORT`; AppKit and Graphiti remain loopback-only.
+
+Add the MCP tools to a Mastra agent with:
+
+```ts
+tools(plugins) {
+  return { ...plugins.graphiti?.toolkit() };
+}
+```
+
+## Configuration
+
+Plugin config overrides environment values:
+
+- `publicPort` / `DATABRICKS_APP_PORT`: Caddy's public port, default `8000`;
+- `appPort` / `GRAPHITI_APP_PORT`: AppKit's internal port, default public + 1;
+- `graphitiPort` / `GRAPHITI_PORT`: Graphiti's internal port; a free loopback
+  port is selected automatically when omitted;
+- `routePrefix` / `GRAPHITI_ROUTE_PREFIX`: public Graphiti prefix, default
+  `/graphiti`;
+- `python` / `PYTHON`: Python executable, default `python3`;
+- `journalNamespace` / `JOURNAL_NAMESPACE`: Postgres journal namespace, default
+  `DATABRICKS_APP_NAME` then `default`.
+
+The app must package both Node and Python dependencies. Databricks Apps supports
+this directly with `package.json` plus `requirements.txt`.
+
+## Modules
+
+- `config` resolves ports, process command, route prefix, and journal namespace;
+- `plugin` starts and supervises Graphiti and Caddy.

package/index.ts

@@ -0,0 +1,10 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-graphiti";
+export * as config from "./src/config.ts";
+export * as plugin from "./src/plugin.ts";
+export { GRAPHITI_CONFIG_SCHEMA } from "./src/config.ts";
+export type { GraphitiPluginConfig, ResolvedGraphitiPluginConfig } from "./src/config.ts";
+export { GraphitiPlugin, graphiti } from "./src/plugin.ts";

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-graphiti";
+export * as config from "./src/config.ts";
+export * as plugin from "./src/plugin.ts";
+export { GRAPHITI_CONFIG_SCHEMA } from "./src/config.ts";
+export type { GraphitiPluginConfig, ResolvedGraphitiPluginConfig } from "./src/config.ts";
+export { GraphitiPlugin, graphiti } from "./src/plugin.ts";

package/lib/index.js

@@ -0,0 +1,9 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit-graphiti";
+export * as config from "./src/config.js";
+export * as plugin from "./src/plugin.js";
+export { GRAPHITI_CONFIG_SCHEMA } from "./src/config.js";
+export { GraphitiPlugin, graphiti } from "./src/plugin.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyw0QkFBNEIsQ0FBQztBQUMvRCxPQUFPLEtBQUssTUFBTSxNQUFNLGlCQUFpQixDQUFDO0FBQzFDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFekQsT0FBTyxFQUFFLGNBQWMsRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCBjb25zdCBQQUNLQUdFX0lERU5USUZJRVIgPSBcIkBkYngtdG9vbHMvYXBwa2l0LWdyYXBoaXRpXCI7XG5leHBvcnQgKiBhcyBjb25maWcgZnJvbSBcIi4vc3JjL2NvbmZpZy50c1wiO1xuZXhwb3J0ICogYXMgcGx1Z2luIGZyb20gXCIuL3NyYy9wbHVnaW4udHNcIjtcbmV4cG9ydCB7IEdSQVBISVRJX0NPTkZJR19TQ0hFTUEgfSBmcm9tIFwiLi9zcmMvY29uZmlnLnRzXCI7XG5leHBvcnQgdHlwZSB7IEdyYXBoaXRpUGx1Z2luQ29uZmlnLCBSZXNvbHZlZEdyYXBoaXRpUGx1Z2luQ29uZmlnIH0gZnJvbSBcIi4vc3JjL2NvbmZpZy50c1wiO1xuZXhwb3J0IHsgR3JhcGhpdGlQbHVnaW4sIGdyYXBoaXRpIH0gZnJvbSBcIi4vc3JjL3BsdWdpbi50c1wiO1xuIl19

package/lib/src/config.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AppKit Graphiti sidecar ports, route prefix, and Python command.
+ *
+ * @module
+ */
+import { type BasePluginConfig } from "@databricks/appkit";
+export interface GraphitiPluginConfig extends BasePluginConfig {
+    publicPort?: number;
+    appPort?: number;
+    graphitiPort?: number;
+    routePrefix?: string;
+    python?: string;
+    journalNamespace?: string;
+}
+export interface ResolvedGraphitiPluginConfig extends GraphitiPluginConfig {
+    publicPort: number;
+    appPort: number;
+    graphitiPort: number;
+    routePrefix: string;
+    python: string;
+    journalNamespace: string;
+}
+export declare const GRAPHITI_CONFIG_SCHEMA: {
+    type: "object";
+    properties: {
+        publicPort: {
+            type: "integer";
+            minimum: number;
+            maximum: number;
+        };
+        appPort: {
+            type: "integer";
+            minimum: number;
+            maximum: number;
+        };
+        graphitiPort: {
+            type: "integer";
+            minimum: number;
+            maximum: number;
+        };
+        routePrefix: {
+            type: "string";
+        };
+        python: {
+            type: "string";
+        };
+        journalNamespace: {
+            type: "string";
+        };
+    };
+    additionalProperties: false;
+};
+/** Resolve plugin config over exact environment values and stable defaults. */
+export declare function resolveGraphitiConfig(config?: GraphitiPluginConfig): ResolvedGraphitiPluginConfig;
+/** Return the internal port an AppKit `server()` plugin should bind. */
+export declare function appPort(config?: GraphitiPluginConfig): number;

package/lib/src/config.js

@@ -0,0 +1,56 @@
+/**
+ * AppKit Graphiti sidecar ports, route prefix, and Python command.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { config as coreConfig } from "@dbx-tools/core";
+export const GRAPHITI_CONFIG_SCHEMA = {
+    type: "object",
+    properties: {
+        publicPort: { type: "integer", minimum: 1, maximum: 65535 },
+        appPort: { type: "integer", minimum: 1, maximum: 65535 },
+        graphitiPort: { type: "integer", minimum: 1, maximum: 65535 },
+        routePrefix: { type: "string" },
+        python: { type: "string" },
+        journalNamespace: { type: "string" },
+    },
+    additionalProperties: false,
+};
+/** Resolve plugin config over exact environment values and stable defaults. */
+export function resolveGraphitiConfig(config = {}) {
+    const publicPort = coreConfig.port(config.publicPort, "DATABRICKS_APP_PORT", 8000, coreConfig.ENV_ONLY);
+    const appPort = coreConfig.port(config.appPort, "GRAPHITI_APP_PORT", publicPort + 1, coreConfig.ENV_ONLY);
+    const graphitiPort = coreConfig.port(config.graphitiPort, "GRAPHITI_PORT", 0, coreConfig.ENV_ONLY);
+    if (new Set([publicPort, appPort, graphitiPort]).size !== 3) {
+        throw new ConfigurationError("Graphiti public, AppKit, and sidecar ports must be distinct");
+    }
+    const routePrefix = normalizeRoutePrefix(config.routePrefix ??
+        coreConfig.text("GRAPHITI_ROUTE_PREFIX", coreConfig.ENV_ONLY) ??
+        "/graphiti");
+    const python = config.python ?? coreConfig.text("PYTHON", coreConfig.ENV_ONLY)?.trim() ?? "python3";
+    const journalNamespace = config.journalNamespace ??
+        coreConfig.text("JOURNAL_NAMESPACE", coreConfig.ENV_ONLY)?.trim() ??
+        process.env.DATABRICKS_APP_NAME?.trim() ??
+        "default";
+    return {
+        publicPort,
+        appPort,
+        graphitiPort,
+        routePrefix,
+        python,
+        journalNamespace,
+    };
+}
+/** Return the internal port an AppKit `server()` plugin should bind. */
+export function appPort(config = {}) {
+    return resolveGraphitiConfig(config).appPort;
+}
+function normalizeRoutePrefix(value) {
+    const normalized = `/${value.trim().replace(/^\/+|\/+$/g, "")}`;
+    if (normalized === "/") {
+        throw new ConfigurationError("Graphiti routePrefix must contain a path segment");
+    }
+    return normalized;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/plugin.d.ts

@@ -0,0 +1,35 @@
+import { Plugin, type PluginManifest, type ResourceRequirement } from "@databricks/appkit";
+import { type GraphitiPluginConfig } from "./config.ts";
+interface ToolkitEntry {
+    pluginName: string;
+    localName: string;
+    def: {
+        name: string;
+        description: string;
+        parameters: unknown;
+    };
+}
+export declare class GraphitiPlugin extends Plugin<GraphitiPluginConfig> {
+    static manifest: PluginManifest<"graphiti">;
+    static getResourceRequirements(): ResourceRequirement[];
+    private readonly logger;
+    private children;
+    private mcp?;
+    private mcpTools;
+    private resolved?;
+    private stopping;
+    setup(): Promise<void>;
+    abortActiveOperations(): void;
+    exports(): {
+        appPort: number;
+        graphitiPort: number;
+        mcpPath: string;
+        publicPort: number;
+        routePrefix: string;
+    };
+    toolkit(): Record<string, ToolkitEntry>;
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown>;
+    private stopGraphiti;
+}
+export declare const graphiti: import("@databricks/appkit").ToPlugin<typeof GraphitiPlugin, GraphitiPluginConfig, "graphiti">;
+export {};

package/lib/src/plugin.js

@@ -0,0 +1,194 @@
+/**
+ * AppKit plugin that supervises Graphiti and a Caddy single-port proxy.
+ *
+ * @module
+ */
+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 { GRAPHITI_CONFIG_SCHEMA, resolveGraphitiConfig, } from "./config.js";
+const LAKEBASE_MANIFEST = appkitPlugin.data(lakebase).plugin.manifest;
+export class GraphitiPlugin extends Plugin {
+    static manifest = {
+        name: "graphiti",
+        displayName: "Graphiti",
+        description: "Runs the dbx-tools Graphiti MCP sidecar with Lakebase-backed recovery and " +
+            "publishes it through the App's single port with Caddy.",
+        stability: "beta",
+        resources: {
+            required: [],
+            optional: [...LAKEBASE_MANIFEST.resources.required],
+        },
+        config: { schema: GRAPHITI_CONFIG_SCHEMA },
+    };
+    static getResourceRequirements() {
+        return LAKEBASE_MANIFEST.resources.required.map((resource) => ({
+            ...resource,
+            required: true,
+        }));
+    }
+    logger = log.logger(this);
+    children = [];
+    mcp;
+    mcpTools = {};
+    resolved;
+    stopping = false;
+    async setup() {
+        const configured = resolveGraphitiConfig(this.config);
+        this.resolved = {
+            ...configured,
+            graphitiPort: configured.graphitiPort || (await availablePort()),
+        };
+        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,
+            },
+            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",
+        });
+        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`),
+                },
+            },
+        });
+        const discovered = await this.mcp.listTools();
+        this.mcpTools = Object.fromEntries(Object.entries(discovered).map(([name, tool]) => [
+            name.replace(/^graphiti_/, ""),
+            tool,
+        ]));
+        this.logger.info("ready", {
+            appPort: this.resolved.appPort,
+            graphitiPort: this.resolved.graphitiPort,
+            publicPort: this.resolved.publicPort,
+            mcpPath: `${this.resolved.routePrefix}/mcp/`,
+            tools: Object.keys(this.mcpTools),
+        });
+    }
+    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 = [];
+    }
+    exports() {
+        const resolved = this.resolved ?? resolveGraphitiConfig(this.config);
+        return {
+            appPort: resolved.appPort,
+            graphitiPort: resolved.graphitiPort,
+            mcpPath: `${resolved.routePrefix}/mcp/`,
+            publicPort: resolved.publicPort,
+            routePrefix: resolved.routePrefix,
+        };
+    }
+    toolkit() {
+        return Object.fromEntries(Object.entries(this.mcpTools).map(([name, tool]) => [
+            name,
+            {
+                pluginName: "graphiti",
+                localName: name,
+                def: {
+                    name,
+                    description: tool.description,
+                    parameters: tool.inputSchema ?? { type: "object", properties: {} },
+                },
+            },
+        ]));
+    }
+    async executeAgentTool(name, args, signal) {
+        const tool = this.mcpTools[name];
+        if (!tool?.execute)
+            throw new Error(`Unknown Graphiti tool: ${name}`);
+        return tool.execute(args, { abortSignal: signal });
+    }
+    stopGraphiti() {
+        if (this.stopping || !this.resolved)
+            return;
+        this.stopping = true;
+        void exec.spawn(this.resolved.python, ["-m", "dbx_tools.graphiti", "down"], {
+            env: process.env,
+            stdin: "ignore",
+            stdout: "inherit",
+            stderr: "inherit",
+        });
+    }
+}
+export const graphiti = toPlugin(GraphitiPlugin);
+async function waitForGraphiti(port) {
+    for await (const ready of asyncModule.poll(async ({ signal }) => {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/health`, { signal });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }, {
+        intervalMs: 250,
+        timeoutMs: 60_000,
+        predicate: (ready) => !ready,
+    })) {
+        if (ready)
+            return;
+    }
+}
+async function availablePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close();
+                reject(new Error("Could not allocate a Graphiti loopback port"));
+                return;
+            }
+            server.close((error) => (error ? reject(error) : resolve(address.port)));
+        });
+    });
+}
+//# 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    this.resolved = {\n      ...configured,\n      graphitiPort: configured.graphitiPort || (await availablePort()),\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      },\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      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      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"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/config.ts","../src/plugin.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@dbx-tools/appkit-graphiti",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/node/appkit-graphiti"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/json-schema": "^7",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@databricks/appkit": "^0.60.0",
+    "@dbx-tools/appkit": "0.6.113",
+    "@dbx-tools/core": "0.6.113",
+    "@dbx-tools/shared-core": "0.6.113",
+    "@mastra/core": "1.47.0",
+    "@mastra/mcp": "1.12.0"
+  },
+  "main": "./lib/index.js",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.6.113",
+  "types": "./lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/config.ts

@@ -0,0 +1,99 @@
+/**
+ * AppKit Graphiti sidecar ports, route prefix, and Python command.
+ *
+ * @module
+ */
+import { ConfigurationError, type BasePluginConfig } from "@databricks/appkit";
+import { config as coreConfig } from "@dbx-tools/core";
+import type { JSONSchema7 } from "json-schema";
+
+export interface GraphitiPluginConfig extends BasePluginConfig {
+  publicPort?: number;
+  appPort?: number;
+  graphitiPort?: number;
+  routePrefix?: string;
+  python?: string;
+  journalNamespace?: string;
+}
+
+export interface ResolvedGraphitiPluginConfig extends GraphitiPluginConfig {
+  publicPort: number;
+  appPort: number;
+  graphitiPort: number;
+  routePrefix: string;
+  python: string;
+  journalNamespace: string;
+}
+
+export const GRAPHITI_CONFIG_SCHEMA = {
+  type: "object",
+  properties: {
+    publicPort: { type: "integer", minimum: 1, maximum: 65535 },
+    appPort: { type: "integer", minimum: 1, maximum: 65535 },
+    graphitiPort: { type: "integer", minimum: 1, maximum: 65535 },
+    routePrefix: { type: "string" },
+    python: { type: "string" },
+    journalNamespace: { type: "string" },
+  },
+  additionalProperties: false,
+} satisfies JSONSchema7;
+
+/** Resolve plugin config over exact environment values and stable defaults. */
+export function resolveGraphitiConfig(
+  config: GraphitiPluginConfig = {},
+): ResolvedGraphitiPluginConfig {
+  const publicPort = coreConfig.port(
+    config.publicPort,
+    "DATABRICKS_APP_PORT",
+    8000,
+    coreConfig.ENV_ONLY,
+  );
+  const appPort = coreConfig.port(
+    config.appPort,
+    "GRAPHITI_APP_PORT",
+    publicPort + 1,
+    coreConfig.ENV_ONLY,
+  );
+  const graphitiPort = coreConfig.port(
+    config.graphitiPort,
+    "GRAPHITI_PORT",
+    0,
+    coreConfig.ENV_ONLY,
+  );
+  if (new Set([publicPort, appPort, graphitiPort]).size !== 3) {
+    throw new ConfigurationError("Graphiti public, AppKit, and sidecar ports must be distinct");
+  }
+  const routePrefix = normalizeRoutePrefix(
+    config.routePrefix ??
+      coreConfig.text("GRAPHITI_ROUTE_PREFIX", coreConfig.ENV_ONLY) ??
+      "/graphiti",
+  );
+  const python =
+    config.python ?? coreConfig.text("PYTHON", coreConfig.ENV_ONLY)?.trim() ?? "python3";
+  const journalNamespace =
+    config.journalNamespace ??
+    coreConfig.text("JOURNAL_NAMESPACE", coreConfig.ENV_ONLY)?.trim() ??
+    process.env.DATABRICKS_APP_NAME?.trim() ??
+    "default";
+  return {
+    publicPort,
+    appPort,
+    graphitiPort,
+    routePrefix,
+    python,
+    journalNamespace,
+  };
+}
+
+/** Return the internal port an AppKit `server()` plugin should bind. */
+export function appPort(config: GraphitiPluginConfig = {}): number {
+  return resolveGraphitiConfig(config).appPort;
+}
+
+function normalizeRoutePrefix(value: string): string {
+  const normalized = `/${value.trim().replace(/^\/+|\/+$/g, "")}`;
+  if (normalized === "/") {
+    throw new ConfigurationError("Graphiti routePrefix must contain a path segment");
+  }
+  return normalized;
+}

package/src/plugin.ts

@@ -0,0 +1,236 @@
+/**
+ * AppKit plugin that supervises Graphiti and a Caddy single-port proxy.
+ *
+ * @module
+ */
+import { createServer } from "node:net";
+import {
+  Plugin,
+  lakebase,
+  toPlugin,
+  type PluginManifest,
+  type ResourceRequirement,
+} 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 type { Tool } from "@mastra/core/tools";
+import { MCPClient } from "@mastra/mcp";
+import {
+  GRAPHITI_CONFIG_SCHEMA,
+  resolveGraphitiConfig,
+  type GraphitiPluginConfig,
+  type ResolvedGraphitiPluginConfig,
+} from "./config.ts";
+
+const LAKEBASE_MANIFEST = appkitPlugin.data(lakebase).plugin.manifest;
+
+interface ToolkitEntry {
+  pluginName: string;
+  localName: string;
+  def: {
+    name: string;
+    description: string;
+    parameters: unknown;
+  };
+}
+
+export class GraphitiPlugin extends Plugin<GraphitiPluginConfig> {
+  static manifest: PluginManifest<"graphiti"> = {
+    name: "graphiti",
+    displayName: "Graphiti",
+    description:
+      "Runs the dbx-tools Graphiti MCP sidecar with Lakebase-backed recovery and " +
+      "publishes it through the App's single port with Caddy.",
+    stability: "beta",
+    resources: {
+      required: [],
+      optional: [...LAKEBASE_MANIFEST.resources.required],
+    },
+    config: { schema: GRAPHITI_CONFIG_SCHEMA },
+  };
+
+  static getResourceRequirements(): ResourceRequirement[] {
+    return LAKEBASE_MANIFEST.resources.required.map((resource) => ({
+      ...resource,
+      required: true,
+    }));
+  }
+
+  private readonly logger = log.logger(this);
+  private children: ReturnType<typeof exec.spawn>[] = [];
+  private mcp?: MCPClient;
+  private mcpTools: Record<string, Tool> = {};
+  private resolved?: ResolvedGraphitiPluginConfig;
+  private stopping = false;
+
+  override async setup(): Promise<void> {
+    const configured = resolveGraphitiConfig(this.config);
+    this.resolved = {
+      ...configured,
+      graphitiPort: configured.graphitiPort || (await availablePort()),
+    };
+    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"] as const) {
+      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,
+      },
+      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",
+      },
+    );
+    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`),
+        },
+      },
+    });
+    const discovered = await this.mcp.listTools();
+    this.mcpTools = Object.fromEntries(
+      Object.entries(discovered).map(([name, tool]) => [
+        name.replace(/^graphiti_/, ""),
+        tool as Tool,
+      ]),
+    );
+    this.logger.info("ready", {
+      appPort: this.resolved.appPort,
+      graphitiPort: this.resolved.graphitiPort,
+      publicPort: this.resolved.publicPort,
+      mcpPath: `${this.resolved.routePrefix}/mcp/`,
+      tools: Object.keys(this.mcpTools),
+    });
+  }
+
+  override abortActiveOperations(): void {
+    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 = [];
+  }
+
+  override exports() {
+    const resolved = this.resolved ?? resolveGraphitiConfig(this.config);
+    return {
+      appPort: resolved.appPort,
+      graphitiPort: resolved.graphitiPort,
+      mcpPath: `${resolved.routePrefix}/mcp/`,
+      publicPort: resolved.publicPort,
+      routePrefix: resolved.routePrefix,
+    };
+  }
+
+  toolkit(): Record<string, ToolkitEntry> {
+    return Object.fromEntries(
+      Object.entries(this.mcpTools).map(([name, tool]) => [
+        name,
+        {
+          pluginName: "graphiti",
+          localName: name,
+          def: {
+            name,
+            description: tool.description,
+            parameters: tool.inputSchema ?? { type: "object", properties: {} },
+          },
+        },
+      ]),
+    );
+  }
+
+  async executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown> {
+    const tool = this.mcpTools[name];
+    if (!tool?.execute) throw new Error(`Unknown Graphiti tool: ${name}`);
+    return tool.execute(args, { abortSignal: signal } as never);
+  }
+
+  private stopGraphiti(): void {
+    if (this.stopping || !this.resolved) return;
+    this.stopping = true;
+    void exec.spawn(this.resolved.python, ["-m", "dbx_tools.graphiti", "down"], {
+      env: process.env,
+      stdin: "ignore",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+  }
+}
+
+export const graphiti = toPlugin(GraphitiPlugin);
+
+async function waitForGraphiti(port: number): Promise<void> {
+  for await (const ready of asyncModule.poll(
+    async ({ signal }) => {
+      try {
+        const response = await fetch(`http://127.0.0.1:${port}/health`, { signal });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    },
+    {
+      intervalMs: 250,
+      timeoutMs: 60_000,
+      predicate: (ready) => !ready,
+    },
+  )) {
+    if (ready) return;
+  }
+}
+
+async function availablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Could not allocate a Graphiti loopback port"));
+        return;
+      }
+      server.close((error) => (error ? reject(error) : resolve(address.port)));
+    });
+  });
+}