@yawlabs/postgres-mcp 0.6.11 → 0.6.13

package/CHANGELOG.md

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.13] - 2026-05-16
+
+### Fixed
+- `pg_kill` now captures postgres's NOTICE channel during
+  `pg_cancel_backend` / `pg_terminate_backend` and surfaces the message in
+  the `note` field when `signaled=false`. Postgres distinguishes "PID N
+  is not a PostgreSQL backend process" from "must be a member of the role
+  whose query is being canceled or member of pg_signal_backend" via
+  NOTICE, but the boolean return collapses both to `false`. Pre-0.6.13
+  the handler returned a generic three-way list and the agent had to
+  guess; now the cause is in the response. Closes #6.
+
+### Docs
+- `pg_kill` description now documents the NOTICE-derived `note` field.
+
+### Internal
+- `formatPgError` is now exported from `api.ts` so handlers that bypass
+  `runInternal` / `withSharedClient` (currently only `pg_kill`) can format
+  errors consistently with the rest of the codebase.
+
+## [0.6.12] - 2026-05-16
+
+### Fixed
+- `pg_inspect_locks` now resolves `relation` for the common case of row-level
+  contention. Previously, `SELECT FOR UPDATE` + `UPDATE` row-level waits
+  queued on a `transactionid` lock with `pg_locks.relation = NULL`, so the
+  handler returned `relation: null` and gave the agent no hint as to which
+  table was contested. A fallback subquery now resolves the contested table
+  from the blocker's held write-intent relation locks (RowShareLock,
+  RowExclusiveLock, etc.), filtering out plain SELECT's AccessShareLock so
+  unrelated tables the blocker only read from don't show up. Closes #5.
+
 ## [0.6.11] - 2026-05-16
 
 ### Infrastructure

package/dist/index.js

@@ -36391,7 +36391,35 @@ var adminTools = [
                      FROM pg_catalog.pg_class c
                      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
                      WHERE c.oid = bl.relation)
-             ELSE NULL
+             ELSE (
+               -- transactionid / virtualxid waits have bl.relation = NULL
+               -- because the wait is on the blocker's xid, not on a relation.
+               -- The contested table is usually identifiable from the
+               -- blocker's held write-intent locks: SELECT FOR UPDATE takes
+               -- RowShareLock, UPDATE/INSERT/DELETE take RowExclusiveLock,
+               -- migrations take stronger modes. Filter out the AccessShare
+               -- locks (plain SELECT) the blocker also holds on every table
+               -- they read from -- those aren't the contention source. If
+               -- the blocker has touched multiple write-intent tables in
+               -- their transaction, this is a best-effort hint, not a
+               -- definitive answer; the blocked/blocking queries above let
+               -- the caller disambiguate.
+               SELECT n.nspname || '.' || c.relname
+               FROM pg_catalog.pg_locks blocker_locks
+               JOIN pg_catalog.pg_class c ON c.oid = blocker_locks.relation
+               JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+               WHERE blocker_locks.pid = blocking.pid
+                 AND blocker_locks.locktype = 'relation'
+                 AND blocker_locks.granted
+                 AND blocker_locks.mode IN (
+                   'RowShareLock', 'RowExclusiveLock', 'ShareLock',
+                   'ShareRowExclusiveLock', 'ShareUpdateExclusiveLock',
+                   'ExclusiveLock', 'AccessExclusiveLock'
+                 )
+                 AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+               ORDER BY n.nspname, c.relname
+               LIMIT 1
+             )
            END AS relation,
            bl.locktype AS lock_type
          FROM pg_catalog.pg_locks bl
@@ -36480,7 +36508,7 @@ var adminTools = [
   },
   {
     name: "pg_kill",
-    description: "Cancel a running query (SIGINT-equivalent) or terminate a backend connection (SIGTERM-equivalent) by PID. Find the PID via `pg_health` active_queries or `pg_inspect_locks`. Requires ALLOW_WRITES=1 since this changes database session state. The role in DATABASE_URL must have permission - cancelling another user's query needs the `pg_signal_backend` role or superuser. Note: `pg_signal_backend` does NOT cover superuser-owned backends - only a superuser can signal another superuser's session. Cancel is graceful; terminate is forceful.",
+    description: "Cancel a running query (SIGINT-equivalent) or terminate a backend connection (SIGTERM-equivalent) by PID. Find the PID via `pg_health` active_queries or `pg_inspect_locks`. Requires ALLOW_WRITES=1 since this changes database session state. The role in DATABASE_URL must have permission - cancelling another user's query needs the `pg_signal_backend` role or superuser. Note: `pg_signal_backend` does NOT cover superuser-owned backends - only a superuser can signal another superuser's session. Cancel is graceful; terminate is forceful. When `signaled=false`, the `note` field surfaces postgres's NOTICE explaining why (e.g. 'not a PostgreSQL backend process' for a non-pg PID, 'must be a member of...' for permission denial) so an agent can act on the specific cause rather than guess from a three-way list.",
     annotations: {
       title: "Cancel or terminate a backend",
       readOnlyHint: false,
@@ -36501,18 +36529,31 @@ var adminTools = [
         };
       }
       const fn = mode === "terminate" ? "pg_terminate_backend" : "pg_cancel_backend";
-      const result = await runInternal(`SELECT ${fn}($1) AS signaled`, [pid]);
-      if (!result.ok) return result;
-      const signaled = result.data?.[0]?.signaled === true;
-      return {
-        ok: true,
-        data: {
-          pid,
-          mode,
-          signaled,
-          note: signaled ? `Sent ${mode === "terminate" ? "SIGTERM" : "SIGINT"} to backend ${pid}.` : `Signal returned false - PID ${pid} may not exist, may already be gone, or the current role lacks permission.`
-        }
+      const client = await getPool().connect();
+      const notices = [];
+      const onNotice = (n) => {
+        if (n.message) notices.push(n.message);
       };
+      client.on("notice", onNotice);
+      try {
+        const result = await client.query(`SELECT ${fn}($1) AS signaled`, [pid]);
+        const signaled = result.rows[0]?.signaled === true;
+        const noticeText = notices.join(" ").trim();
+        return {
+          ok: true,
+          data: {
+            pid,
+            mode,
+            signaled,
+            note: signaled ? `Sent ${mode === "terminate" ? "SIGTERM" : "SIGINT"} to backend ${pid}.` : noticeText ? `${noticeText} (Signal returned false for PID ${pid}.)` : `Signal returned false - PID ${pid} may not exist, may already be gone, or the current role lacks permission.`
+          }
+        };
+      } catch (err) {
+        return { ok: false, error: formatPgError(err) };
+      } finally {
+        client.off("notice", onNotice);
+        client.release();
+      }
     }
   },
   {
@@ -37550,7 +37591,7 @@ function compareVersions(a, b) {
 }
 
 // src/index.ts
-var version2 = true ? "0.6.11" : (await null).createRequire(import.meta.url)("../package.json").version;
+var version2 = true ? "0.6.13" : (await null).createRequire(import.meta.url)("../package.json").version;
 var subcommand = process.argv[2];
 if (subcommand === "version" || subcommand === "--version") {
   console.log(version2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/postgres-mcp",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "mcpName": "io.github.YawLabs/postgres-mcp",
   "description": "PostgreSQL MCP server - query, schema introspection, explain, and health checks for AI assistants",
   "license": "MIT",