@alfe.ai/openclaw-database 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -0,0 +1,2 @@
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;

package/dist/index.d.cts

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

package/dist/plugin.cjs

@@ -0,0 +1,2 @@
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;

package/dist/plugin.d.cts

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

package/dist/plugin2.cjs

@@ -0,0 +1,529 @@
+let mongodb = require("mongodb");
+let _alfe_ai_config = require("@alfe.ai/config");
+//#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, lazyInit) {
+	async function db(name) {
+		const { mongoClient, databases } = lazyInit ? await lazyInit() : {
+			mongoClient: _client ?? (() => {
+				throw new Error("MongoDB client not initialized");
+			})(),
+			databases: _databases
+		};
+		const dbName = name ?? DEFAULT_DB;
+		if (!databases.includes(dbName)) throw new Error(`Access denied: database "${dbName}" is not in the allowed list`);
+		return mongoClient.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 (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 (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 (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 (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 (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 (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 (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: async () => {
+			const { databases } = lazyInit ? await lazyInit() : { databases: _databases };
+			return { 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 (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 (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 (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 (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 = (await 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 (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 (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 (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
+let mongoClient = null;
+let initPromise = 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;
+}
+/**
+* Lazy initializer — fetches credentials and connects to MongoDB on first use.
+* Returns a shared promise so concurrent calls don't duplicate work.
+*/
+function ensureInitialized(apiUrl, apiKey) {
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		const credentials = await fetchCredentials(apiUrl, apiKey);
+		if (!credentials.connectionString) throw new Error("No connection string returned — cluster may still be provisioning");
+		const url = new URL(credentials.connectionString);
+		url.username = credentials.username;
+		url.password = credentials.password;
+		const client = new mongodb.MongoClient(url.toString(), {
+			maxPoolSize: 3,
+			minPoolSize: 1,
+			serverSelectionTimeoutMS: 5e3
+		});
+		await client.connect();
+		mongoClient = client;
+		return {
+			mongoClient: client,
+			databases: credentials.databases,
+			apiUrl,
+			apiKey
+		};
+	})();
+	initPromise.catch(() => {
+		initPromise = null;
+	});
+	return initPromise;
+}
+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: "@alfe.ai/openclaw-database",
+	name: "Database",
+	version: "0.0.1",
+	activate(api) {
+		const log = api.logger;
+		if (!("runtime" in api)) {
+			log.debug("Management command context — skipping database init");
+			return;
+		}
+		log.info("Database plugin activating...");
+		let apiUrl;
+		let apiKey;
+		try {
+			const config = (0, _alfe_ai_config.resolveConfig)();
+			apiUrl = config.apiUrl;
+			apiKey = config.apiKey;
+		} catch (err) {
+			log.error(`Database plugin: failed to resolve config — ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
+		ensureInitialized(apiUrl, apiKey).then(({ databases }) => {
+			log.info(`Database plugin connected — ${String(databases.length)} databases available`);
+		}).catch((err) => {
+			log.warn(`Database plugin: background init failed (will retry on first tool use) — ${err instanceof Error ? err.message : String(err)}`);
+		});
+		registerTools(api, null, [], (entry) => {
+			reportAudit(apiUrl, apiKey, entry);
+		}, () => ensureInitialized(apiUrl, apiKey));
+	},
+	async deactivate(api) {
+		api.logger.info("Database plugin deactivating...");
+		if (mongoClient) {
+			await mongoClient.close();
+			mongoClient = null;
+		}
+	}
+};
+//#endregion
+Object.defineProperty(exports, "plugin", {
+	enumerable: true,
+	get: function() {
+		return plugin;
+	}
+});

package/dist/plugin2.js

@@ -488,6 +488,10 @@ const plugin = {
 	version: "0.0.1",
 	activate(api) {
 		const log = api.logger;
+		if (!("runtime" in api)) {
+			log.debug("Management command context — skipping database init");
+			return;
+		}
 		log.info("Database plugin activating...");
 		let apiUrl;
 		let apiKey;

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@alfe.ai/openclaw-database",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./plugin": {
-      "import": "./dist/plugin.js",
-      "types": "./dist/plugin.d.ts"
+      "types": "./dist/plugin.d.ts",
+      "require": "./dist/plugin.cjs",
+      "import": "./dist/plugin.js"
     }
   },
   "openclaw": {
@@ -26,7 +28,7 @@
   ],
   "dependencies": {
     "mongodb": "^6.12.0",
-    "@alfe.ai/config": "0.0.6"
+    "@alfe.ai/config": "0.0.7"
   },
   "license": "UNLICENSED",
   "scripts": {