easy-pg-admin-mcp 0.1.0 → 0.1.2

package/README.md

@@ -56,6 +56,7 @@ Use environment variables, matching the rest of the `easy-*-mcp` family.
 | `PG_PASSWORD` | No | - | PostgreSQL password |
 | `PG_DATABASE` | Conditional | - | Default database used for the admin connection |
 | `PG_CONNECTION_LIMIT` | No | `10` | Maximum number of active pool connections |
+| `PG_CONNECTION_TIMEOUT` | No | `10000` | Connection establishment timeout in milliseconds |
 | `PG_IDLE_TIMEOUT` | No | `30000` | Idle connection timeout in milliseconds |
 | `PG_ENABLE_KEEP_ALIVE` | No | `true` | Whether TCP keep-alive is enabled |
 | `PG_KEEP_ALIVE_INITIAL_DELAY` | No | `0` | Initial TCP keep-alive delay in milliseconds |

package/README.zh-TW.md

@@ -56,6 +56,7 @@
 | `PG_PASSWORD` | 否 | - | PostgreSQL 密碼 |
 | `PG_DATABASE` | 條件必填 | - | 管理連線使用的預設 database |
 | `PG_CONNECTION_LIMIT` | 否 | `10` | pool 最大 active connections |
+| `PG_CONNECTION_TIMEOUT` | 否 | `10000` | 建立 PostgreSQL 連線的逾時時間，單位毫秒 |
 | `PG_IDLE_TIMEOUT` | 否 | `30000` | idle connection timeout，單位毫秒 |
 | `PG_ENABLE_KEEP_ALIVE` | 否 | `true` | 是否啟用 TCP keep-alive |
 | `PG_KEEP_ALIVE_INITIAL_DELAY` | 否 | `0` | TCP keep-alive 初始延遲，單位毫秒 |

package/build/config.js

@@ -29,6 +29,7 @@ export function parseAdminConfig(env) {
             password: env.PG_PASSWORD,
             database: env.PG_DATABASE ?? '',
             connectionLimit: parsePositiveInt(env.PG_CONNECTION_LIMIT, 10),
+            connectionTimeout: parsePositiveInt(env.PG_CONNECTION_TIMEOUT, 10000),
             idleTimeout: parsePositiveInt(env.PG_IDLE_TIMEOUT, 30000),
             enableKeepAlive: parseBoolean(env.PG_ENABLE_KEEP_ALIVE, true),
             keepAliveInitialDelay: env.PG_KEEP_ALIVE_INITIAL_DELAY ? Number.parseInt(env.PG_KEEP_ALIVE_INITIAL_DELAY, 10) : 0,

package/build/db.js

@@ -17,6 +17,7 @@ export function getPool() {
         password: config.pg.connectionString ? undefined : config.pg.password,
         database: config.pg.connectionString ? undefined : config.pg.database,
         max: config.pg.connectionLimit,
+        connectionTimeoutMillis: config.pg.connectionTimeout,
         idleTimeoutMillis: config.pg.idleTimeout,
         keepAlive: config.pg.enableKeepAlive,
         keepAliveInitialDelayMillis: config.pg.keepAliveInitialDelay,
@@ -24,6 +25,9 @@ export function getPool() {
     });
     return pool;
 }
+export async function verifyConnection() {
+    await getPool().query('SELECT 1');
+}
 export function escapeIdentifier(identifier) {
     return `"${identifier.replace(/"/g, '""')}"`;
 }

package/build/index.js

@@ -4,8 +4,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { parseAdminConfig } from './config.js';
 import { createConfirmationStore } from './confirmationStore.js';
-import { getPool } from './db.js';
-import { createAdminHandlers } from './toolHandlers.js';
+import { getPool, verifyConnection } from './db.js';
+import { createAdminHandlers, formatError } from './toolHandlers.js';
 const config = parseAdminConfig(process.env);
 const store = createConfirmationStore({ defaultTtlMs: config.tokenTtlSeconds * 1000 });
 getPool();
@@ -25,15 +25,24 @@ const roleAttributesSchema = {
     connectionLimit: z.number().int().min(-1).optional(),
     validUntil: z.string().min(1).nullable().optional(),
 };
-function textJson(value) {
+function textJson(value, isError = false) {
     return {
         content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        ...(isError ? { isError: true } : {}),
     };
 }
+async function safeTextJson(operation) {
+    try {
+        return textJson(await operation());
+    }
+    catch (error) {
+        return textJson(formatError(error), true);
+    }
+}
 server.registerTool('pg_list_databases', {
     description: 'List databases in the current PostgreSQL instance.',
     inputSchema: z.object({}),
-}, async () => textJson(await handlers.listDatabases()));
+}, async () => safeTextJson(() => handlers.listDatabases()));
 server.registerTool('pg_create_database', {
     description: 'Create a PostgreSQL database.',
     inputSchema: z.object({
@@ -43,33 +52,33 @@ server.registerTool('pg_create_database', {
         template: z.string().min(1).optional(),
         locale: z.string().min(1).optional(),
     }),
-}, async ({ database, owner, encoding, template, locale }) => textJson(await handlers.createDatabase({ database, owner, encoding, template, locale })));
+}, async ({ database, owner, encoding, template, locale }) => safeTextJson(() => handlers.createDatabase({ database, owner, encoding, template, locale })));
 server.registerTool('pg_describe_database', {
     description: 'Inspect a PostgreSQL database definition.',
     inputSchema: z.object({
         database: z.string().min(1),
     }),
-}, async ({ database }) => textJson(await handlers.describeDatabase(database)));
+}, async ({ database }) => safeTextJson(() => handlers.describeDatabase(database)));
 server.registerTool('pg_alter_database_owner', {
     description: 'Change the owner of a PostgreSQL database.',
     inputSchema: z.object({
         database: z.string().min(1),
         owner: z.string().min(1),
     }),
-}, async ({ database, owner }) => textJson(await handlers.alterDatabaseOwner(database, owner)));
+}, async ({ database, owner }) => safeTextJson(() => handlers.alterDatabaseOwner(database, owner)));
 server.registerTool('pg_drop_database', {
     description: 'Request database deletion and return a short-lived confirmation token.',
     inputSchema: z.object({
         database: z.string().min(1),
         force: z.boolean().optional(),
     }),
-}, async ({ database, force }) => textJson(await handlers.dropDatabase(database, { force })));
+}, async ({ database, force }) => safeTextJson(() => handlers.dropDatabase(database, { force })));
 server.registerTool('pg_list_roles', {
     description: 'List PostgreSQL roles.',
     inputSchema: z.object({
         includeSystem: z.boolean().optional(),
     }),
-}, async ({ includeSystem }) => textJson(await handlers.listRoles({ includeSystem })));
+}, async ({ includeSystem }) => safeTextJson(() => handlers.listRoles({ includeSystem })));
 server.registerTool('pg_create_role', {
     description: 'Create a PostgreSQL role. SUPERUSER is intentionally not supported.',
     inputSchema: z.object({
@@ -77,7 +86,7 @@ server.registerTool('pg_create_role', {
         password: z.string().min(1).optional(),
         ...roleAttributesSchema,
     }),
-}, async ({ role, password, login, createdb, createrole, inherit, replication, bypassrls, connectionLimit, validUntil }) => textJson(await handlers.createRole({
+}, async ({ role, password, login, createdb, createrole, inherit, replication, bypassrls, connectionLimit, validUntil }) => safeTextJson(() => handlers.createRole({
     role,
     password,
     login,
@@ -95,14 +104,14 @@ server.registerTool('pg_alter_role_password', {
         role: z.string().min(1),
         password: z.string().min(1),
     }),
-}, async ({ role, password }) => textJson(await handlers.alterRolePassword(role, password)));
+}, async ({ role, password }) => safeTextJson(() => handlers.alterRolePassword(role, password)));
 server.registerTool('pg_alter_role_attributes', {
     description: 'Change PostgreSQL role attributes. SUPERUSER is intentionally not supported.',
     inputSchema: z.object({
         role: z.string().min(1),
         ...roleAttributesSchema,
     }),
-}, async ({ role, login, createdb, createrole, inherit, replication, bypassrls, connectionLimit, validUntil }) => textJson(await handlers.alterRoleAttributes(role, {
+}, async ({ role, login, createdb, createrole, inherit, replication, bypassrls, connectionLimit, validUntil }) => safeTextJson(() => handlers.alterRoleAttributes(role, {
     login,
     createdb,
     createrole,
@@ -117,7 +126,7 @@ server.registerTool('pg_drop_role', {
     inputSchema: z.object({
         role: z.string().min(1),
     }),
-}, async ({ role }) => textJson(await handlers.dropRole(role)));
+}, async ({ role }) => safeTextJson(() => handlers.dropRole(role)));
 server.registerTool('pg_grant_role', {
     description: 'Grant a PostgreSQL role to another role.',
     inputSchema: z.object({
@@ -125,7 +134,7 @@ server.registerTool('pg_grant_role', {
         member: z.string().min(1),
         adminOption: z.boolean().optional(),
     }),
-}, async ({ role, member, adminOption }) => textJson(await handlers.grantRole({ role, member, adminOption })));
+}, async ({ role, member, adminOption }) => safeTextJson(() => handlers.grantRole({ role, member, adminOption })));
 server.registerTool('pg_revoke_role', {
     description: 'Revoke a PostgreSQL role from another role.',
     inputSchema: z.object({
@@ -133,13 +142,13 @@ server.registerTool('pg_revoke_role', {
         member: z.string().min(1),
         adminOption: z.boolean().optional(),
     }),
-}, async ({ role, member, adminOption }) => textJson(await handlers.revokeRole({ role, member, adminOption })));
+}, async ({ role, member, adminOption }) => safeTextJson(() => handlers.revokeRole({ role, member, adminOption })));
 server.registerTool('pg_show_role_memberships', {
     description: 'Show memberships for a PostgreSQL role.',
     inputSchema: z.object({
         role: z.string().min(1),
     }),
-}, async ({ role }) => textJson(await handlers.showRoleMemberships(role)));
+}, async ({ role }) => safeTextJson(() => handlers.showRoleMemberships(role)));
 server.registerTool('pg_grant_privileges', {
     description: 'Grant database-level PostgreSQL privileges to a role.',
     inputSchema: z.object({
@@ -148,7 +157,7 @@ server.registerTool('pg_grant_privileges', {
         privileges: z.array(z.string().min(1)).min(1),
         withGrantOption: z.boolean().optional(),
     }),
-}, async ({ role, database, privileges, withGrantOption }) => textJson(await handlers.grantPrivileges({ role, database, privileges, withGrantOption })));
+}, async ({ role, database, privileges, withGrantOption }) => safeTextJson(() => handlers.grantPrivileges({ role, database, privileges, withGrantOption })));
 server.registerTool('pg_revoke_privileges', {
     description: 'Revoke database-level PostgreSQL privileges from a role.',
     inputSchema: z.object({
@@ -157,21 +166,22 @@ server.registerTool('pg_revoke_privileges', {
         privileges: z.array(z.string().min(1)).min(1),
         grantOptionFor: z.boolean().optional(),
     }),
-}, async ({ role, database, privileges, grantOptionFor }) => textJson(await handlers.revokePrivileges({ role, database, privileges, grantOptionFor })));
+}, async ({ role, database, privileges, grantOptionFor }) => safeTextJson(() => handlers.revokePrivileges({ role, database, privileges, grantOptionFor })));
 server.registerTool('pg_show_grants', {
     description: 'Show database-level PostgreSQL grants for a role.',
     inputSchema: z.object({
         role: z.string().min(1),
         database: z.string().min(1).optional(),
     }),
-}, async ({ role, database }) => textJson(await handlers.showGrants({ role, database })));
+}, async ({ role, database }) => safeTextJson(() => handlers.showGrants({ role, database })));
 server.registerTool('pg_confirm_task', {
     description: 'Confirm and execute a previously issued destructive action token.',
     inputSchema: z.object({
         token: z.string().min(1),
     }),
-}, async ({ token }) => textJson(await handlers.confirmTask(token)));
+}, async ({ token }) => safeTextJson(() => handlers.confirmTask(token)));
 async function main() {
+    await verifyConnection();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('easy-pg-admin-mcp running on stdio');

package/build/toolHandlers.js

@@ -1,9 +1,12 @@
 import { escapeIdentifier, getPool } from './db.js';
 import { assertNoSuperuser, formatPrivilegeList, parseRoleAttributes, validateDatabaseName, validateExistingRoleName, validateRoleName, } from './validation.js';
 export function formatError(error, code = 'ADMIN_OPERATION_FAILED') {
+    const postgresCode = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
+        ? error.code
+        : undefined;
     return {
         error: error instanceof Error ? error.message : String(error),
-        code,
+        code: postgresCode ?? code,
     };
 }
 export function createAdminHandlers(store, tokenTtlSeconds) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-pg-admin-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "High privilege PostgreSQL admin MCP server for database and role management",
   "keywords": [
     "mcp",
@@ -45,14 +45,14 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "pg": "^8.21.0",
-    "zod": "^4.4.3"
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "pg": "^8.23.0",
+    "zod": "^4.5.4"
   },
   "devDependencies": {
-    "@types/node": "^25.9.3",
-    "@types/pg": "^8.20.0",
-    "typescript": "^6.0.3"
+    "@types/node": "^26.5.0",
+    "@types/pg": "^8.23.1",
+    "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=20"