@alfe.ai/openclaw-database 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import plugin from "./plugin.js";
+export { plugin as default };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin2.js";
+export { plugin as default };

package/dist/plugin.d.ts

@@ -0,0 +1,25 @@
+//#region src/plugin.d.ts
+interface PluginApi {
+  logger: {
+    info: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+  };
+  config?: {
+    plugins?: {
+      entries?: Record<string, {
+        config?: Record<string, string>;
+      }>;
+    };
+  };
+  registerTool(tool: unknown): void;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  version: string;
+  activate(api: PluginApi): Promise<void>;
+  deactivate(api: PluginApi): Promise<void>;
+};
+//#endregion
+export { plugin as default };

package/dist/plugin.js

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin2.js";
+export { plugin as default };

package/dist/plugin2.js

@@ -0,0 +1,486 @@
+import { MongoClient } from "mongodb";
+//#region src/tools.ts
+const DEFAULT_DB = "org_default";
+function str(required = true) {
+	return {
+		type: "string",
+		...required ? {} : { default: "" }
+	};
+}
+function optStr() {
+	return {
+		type: "string",
+		default: ""
+	};
+}
+function registerTools(api, client, databases, audit) {
+	function db(name) {
+		const dbName = name ?? DEFAULT_DB;
+		if (!databases.includes(dbName)) throw new Error(`Access denied: database "${dbName}" is not in the allowed list`);
+		return client.db(dbName);
+	}
+	api.registerTool({
+		name: "db_find",
+		description: "Find documents matching a filter",
+		label: "db_find",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				filter: {
+					type: "object",
+					default: {}
+				},
+				sort: {
+					type: "object",
+					default: {}
+				},
+				limit: {
+					type: "number",
+					default: 20
+				},
+				skip: {
+					type: "number",
+					default: 0
+				},
+				projection: {
+					type: "object",
+					default: {}
+				}
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			const docs = await db(p.database).collection(p.collection).find(p.filter).sort(p.sort).project(p.projection).skip(p.skip || 0).limit(p.limit || 20).toArray();
+			return {
+				documents: docs,
+				count: docs.length
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_find_one",
+		description: "Find a single document matching a filter",
+		label: "db_find_one",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				filter: {
+					type: "object",
+					default: {}
+				},
+				projection: {
+					type: "object",
+					default: {}
+				}
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			return await db(p.database).collection(p.collection).findOne(p.filter, { projection: p.projection }) ?? { _not_found: true };
+		}
+	});
+	api.registerTool({
+		name: "db_insert",
+		description: "Insert one or more documents",
+		label: "db_insert",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				documents: {
+					type: "array",
+					items: { type: "object" }
+				}
+			},
+			required: ["collection", "documents"]
+		},
+		execute: async (_id, p) => {
+			const docs = p.documents;
+			const result = await db(p.database).collection(p.collection).insertMany(docs);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "insert",
+				summary: `Inserted ${String(docs.length)} document(s)`
+			});
+			return {
+				insertedCount: result.insertedCount,
+				insertedIds: Object.values(result.insertedIds).map(String)
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_update",
+		description: "Update documents matching a filter",
+		label: "db_update",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				filter: { type: "object" },
+				update: { type: "object" },
+				upsert: {
+					type: "boolean",
+					default: false
+				}
+			},
+			required: [
+				"collection",
+				"filter",
+				"update"
+			]
+		},
+		execute: async (_id, p) => {
+			const result = await db(p.database).collection(p.collection).updateMany(p.filter, p.update, { upsert: p.upsert || false });
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "update",
+				summary: `Modified ${String(result.modifiedCount)}`
+			});
+			return {
+				matchedCount: result.matchedCount,
+				modifiedCount: result.modifiedCount,
+				upsertedId: result.upsertedId ? String(result.upsertedId) : null
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_delete",
+		description: "Delete documents matching a filter",
+		label: "db_delete",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				filter: { type: "object" }
+			},
+			required: ["collection", "filter"]
+		},
+		execute: async (_id, p) => {
+			const result = await db(p.database).collection(p.collection).deleteMany(p.filter);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "delete",
+				summary: `Deleted ${String(result.deletedCount)}`
+			});
+			return { deletedCount: result.deletedCount };
+		}
+	});
+	api.registerTool({
+		name: "db_count",
+		description: "Count documents matching a filter",
+		label: "db_count",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				filter: {
+					type: "object",
+					default: {}
+				}
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			return { count: await db(p.database).collection(p.collection).countDocuments(p.filter) };
+		}
+	});
+	api.registerTool({
+		name: "db_aggregate",
+		description: "Run an aggregation pipeline",
+		label: "db_aggregate",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				pipeline: {
+					type: "array",
+					items: { type: "object" }
+				}
+			},
+			required: ["collection", "pipeline"]
+		},
+		execute: async (_id, p) => {
+			const results = await db(p.database).collection(p.collection).aggregate(p.pipeline).toArray();
+			return {
+				results,
+				count: results.length
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_list_databases",
+		description: "List databases the agent can access",
+		label: "db_list_databases",
+		parameters: {
+			type: "object",
+			properties: {}
+		},
+		execute: () => Promise.resolve({ databases })
+	});
+	api.registerTool({
+		name: "db_list_collections",
+		description: "List collections in a database",
+		label: "db_list_collections",
+		parameters: {
+			type: "object",
+			properties: { database: optStr() }
+		},
+		execute: async (_id, p) => {
+			return { collections: (await db(p.database).listCollections().toArray()).map((c) => ({
+				name: c.name,
+				type: c.type
+			})) };
+		}
+	});
+	api.registerTool({
+		name: "db_create_collection",
+		description: "Create a new collection",
+		label: "db_create_collection",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str()
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			await db(p.database).createCollection(p.collection);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "create_collection"
+			});
+			return { success: true };
+		}
+	});
+	api.registerTool({
+		name: "db_drop_collection",
+		description: "Drop a collection",
+		label: "db_drop_collection",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str()
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			await db(p.database).dropCollection(p.collection);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "drop_collection"
+			});
+			return { success: true };
+		}
+	});
+	api.registerTool({
+		name: "db_collection_schema",
+		description: "Inspect a collection's schema by sampling documents",
+		label: "db_collection_schema",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str()
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			const sample = await db(p.database).collection(p.collection).find().limit(100).toArray();
+			const fieldTypes = /* @__PURE__ */ new Map();
+			for (const doc of sample) for (const [key, value] of Object.entries(doc)) {
+				const types = fieldTypes.get(key) ?? /* @__PURE__ */ new Set();
+				types.add(value === null ? "null" : typeof value);
+				fieldTypes.set(key, types);
+			}
+			return {
+				sampleSize: sample.length,
+				fields: [...fieldTypes.entries()].map(([name, types]) => ({
+					name,
+					types: [...types]
+				}))
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_collection_stats",
+		description: "Get collection doc count, size, and indexes",
+		label: "db_collection_stats",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str()
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			const coll = db(p.database).collection(p.collection);
+			const count = await coll.countDocuments();
+			const indexes = await coll.indexes();
+			return {
+				count,
+				indexCount: indexes.length,
+				indexes: indexes.map((i) => ({
+					name: i.name,
+					key: i.key
+				}))
+			};
+		}
+	});
+	api.registerTool({
+		name: "db_create_index",
+		description: "Create an index on a collection",
+		label: "db_create_index",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				keys: { type: "object" },
+				options: {
+					type: "object",
+					default: {}
+				}
+			},
+			required: ["collection", "keys"]
+		},
+		execute: async (_id, p) => {
+			const indexName = await db(p.database).collection(p.collection).createIndex(p.keys, p.options);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "create_index",
+				summary: indexName
+			});
+			return { indexName };
+		}
+	});
+	api.registerTool({
+		name: "db_list_indexes",
+		description: "List indexes on a collection",
+		label: "db_list_indexes",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str()
+			},
+			required: ["collection"]
+		},
+		execute: async (_id, p) => {
+			return { indexes: (await db(p.database).collection(p.collection).indexes()).map((i) => ({
+				name: i.name,
+				key: i.key,
+				unique: i.unique
+			})) };
+		}
+	});
+	api.registerTool({
+		name: "db_drop_index",
+		description: "Drop an index by name",
+		label: "db_drop_index",
+		parameters: {
+			type: "object",
+			properties: {
+				database: optStr(),
+				collection: str(),
+				indexName: str()
+			},
+			required: ["collection", "indexName"]
+		},
+		execute: async (_id, p) => {
+			await db(p.database).collection(p.collection).dropIndex(p.indexName);
+			audit({
+				database: p.database || DEFAULT_DB,
+				collection: p.collection,
+				operation: "drop_index",
+				summary: p.indexName
+			});
+			return { success: true };
+		}
+	});
+}
+//#endregion
+//#region src/plugin.ts
+const PLUGIN_ID = "@alfe.ai/openclaw-database";
+let mongoClient = null;
+async function fetchCredentials(apiUrl, apiKey) {
+	const res = await fetch(`${apiUrl}/agents/database/register`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		}
+	});
+	if (!res.ok) throw new Error(`Failed to register database credentials: ${String(res.status)} ${res.statusText}`);
+	return (await res.json()).data;
+}
+function reportAudit(apiUrl, apiKey, entry) {
+	fetch(`${apiUrl}/agents/database/audit`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify(entry)
+	}).catch(() => {});
+}
+const plugin = {
+	id: PLUGIN_ID,
+	name: "Database",
+	version: "0.0.1",
+	async activate(api) {
+		const log = api.logger;
+		log.info("Database plugin activating...");
+		const pluginConfig = api.config?.plugins?.entries?.[PLUGIN_ID]?.config ?? {};
+		const apiUrl = pluginConfig.apiUrl || (process.env.ALFE_API_URL ?? "");
+		const apiKey = pluginConfig.apiKey || (process.env.ALFE_API_KEY ?? "");
+		if (!apiUrl || !apiKey) {
+			log.error("Database plugin: missing apiUrl or apiKey — skipping activation");
+			return;
+		}
+		const credentials = await fetchCredentials(apiUrl, apiKey);
+		if (!credentials.connectionString) {
+			log.error("Database plugin: no connection string returned — cluster may still be provisioning");
+			return;
+		}
+		const url = new URL(credentials.connectionString);
+		url.username = credentials.username;
+		url.password = credentials.password;
+		mongoClient = new MongoClient(url.toString(), {
+			maxPoolSize: 3,
+			minPoolSize: 1,
+			serverSelectionTimeoutMS: 5e3
+		});
+		await mongoClient.connect();
+		log.info(`Database plugin connected — ${String(credentials.databases.length)} databases available`);
+		registerTools(api, mongoClient, credentials.databases, (entry) => {
+			reportAudit(apiUrl, apiKey, entry);
+		});
+	},
+	async deactivate(api) {
+		api.logger.info("Database plugin deactivating...");
+		if (mongoClient) {
+			await mongoClient.close();
+			mongoClient = null;
+		}
+	}
+};
+//#endregion
+export { plugin as t };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@alfe.ai/openclaw-database",
+  "version": "0.0.1",
+  "description": "OpenClaw database plugin — MongoDB access for agents via MCP tools",
+  "type": "module",
+  "main": "./dist/plugin.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./plugin": {
+      "import": "./dist/plugin.js",
+      "types": "./dist/plugin.d.ts"
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/plugin.js"
+    ]
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "mongodb": "^6.12.0"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}