@lensmcp/protocol-types 1.25.0 → 1.25.2

package/lib/dashboard.d.ts

@@ -516,7 +516,9 @@ export interface DashLogsFrame {
 export type DashProblemSeverity = 'high' | 'medium' | 'low';
 export type DashProblemKind = 'n-plus-one' | 'db-in-loop' | 'render-storm' | 'slow-path' | 'slow-route' | 'slow-query' | 'missing-index' | 'leak' | 'server-error' | 'browser-error' | 'failed-span' | 'egress-failing' | 'egress-slow' | 'duplicate-requests' | 'build' | 'typecheck' | 'lint' | 'service'
 /** A performance rule's finding (`perf://rules`): build or memory cost, with its fix and how to verify it. */
- | 'perf-rule' | 'other';
+ | 'perf-rule'
+/** A service could not get a database connection, and why (`db://pool`): a hot swap or a blocked loop, a full pool, Postgres full. */
+ | 'db-connection' | 'other';
 export interface DashProblem {
     /** Stable across updates — the card's identity for the resolved-lifecycle. */
     id: string;
@@ -1233,6 +1235,62 @@ export interface DashDbStore {
     /** Connections to the server, all databases. */
     connections?: number;
 }
+/**
+ * Data › Databases › Connections: who holds the server's connections, against its limit — read from `pg_stat_activity`
+ * (every database on the server: `max_connections` is the server's). A connection the lens's pg tap opened names its
+ * service and app generation (`foodguard lens:engine:g12`), so a generation a hot swap replaced shows apart.
+ */
+export interface DashDbConnections {
+    at: number;
+    store: string;
+    state: 'ok' | 'error';
+    reason?: string;
+    /** `max_connections`, and the slots kept for superusers and `pg_use_reserved_connections` — what the apps cannot use. */
+    max?: number;
+    reserved?: number;
+    /** Client connections now (every database). */
+    used?: number;
+    /** One row per application name (and database), the most connections first. */
+    apps: DashDbConnApp[];
+    /** The sessions worth a look: open in a transaction, waiting on a lock, or running for over a second. */
+    sessions: DashDbConnSession[];
+}
+export interface DashDbConnApp {
+    /** As Postgres has it: `foodguard lens:engine:g12`. */
+    app: string;
+    /** From the lens's tag: the service, and the app generation that opened the connections. */
+    service?: string;
+    generation?: number;
+    /** An older generation of a service whose newer one holds connections too — a hot swap that never closed its pool. */
+    leftover?: boolean;
+    database?: string;
+    total: number;
+    active: number;
+    idle: number;
+    idleInTransaction: number;
+    waiting: number;
+    /** The oldest of these connections, ms. */
+    oldestMs?: number;
+}
+export interface DashDbConnSession {
+    pid: number;
+    app: string;
+    service?: string;
+    generation?: number;
+    database?: string;
+    state: string;
+    /** `Lock: transactionid` — what it waits on. */
+    waiting?: string;
+    /** How long its transaction has been open, and how long it has been in this state, ms. */
+    xactMs?: number;
+    stateMs?: number;
+    /** Its statement as a shape (no values): the SQL catalog's id, name and template. */
+    statement?: {
+        id: string;
+        name?: string;
+        text: string;
+    };
+}
 export interface DashDbDatabase {
     name: string;
     bytes?: number;
@@ -1912,6 +1970,8 @@ export interface DashAiRun {
     workspace: string;
     /** `queued`: waiting for a free slot (`queue` says how many are ahead); one job per target, at most N at once. */
     status: 'queued' | 'running' | 'done' | 'failed';
+    /** Started by itself (Settings › Features — a route that changed, a statement once named); absent: someone asked. */
+    trigger?: 'auto';
     queue?: {
         ahead: number;
         max: number;
@@ -2060,6 +2120,66 @@ export interface DashReviewMark {
     overall?: number;
     warning?: boolean;
 }
+/**
+ * A target's review as a drawer or a list shows it without opening it — read only, nothing is started
+ * (`/api/ai/review-status`, `/api/ai/review-marks`). `none`: never reviewed; `reviewing`: a run waits or runs now
+ * (`progress`); `reviewed`: its newest review holds, as far as the lens has checked (`checkedAt`); `stale`: it no
+ * longer holds — the thing or the instructions changed since (`why`); `failed`: the newest run failed (`why`). The
+ * newest finished review comes with each state but `none`.
+ */
+export interface DashReviewStatus {
+    /** `<kind>:<id>`. */
+    target: string;
+    state: 'none' | 'reviewing' | 'reviewed' | 'stale' | 'failed';
+    /** Why it is out of date, or why its newest run failed. */
+    why?: string;
+    /** When the lens last asked the analyzer whether the review still holds against the thing as it is now; absent: not yet. */
+    checkedAt?: number;
+    review?: DashReviewSummary;
+    /** The run waiting or running now: its step, how many are ahead of it, how far Claude got. */
+    progress?: {
+        runId: string;
+        status: 'queued' | 'running';
+        startedAt: number;
+        step?: string;
+        ahead?: number;
+        turns?: number;
+        tools?: number;
+    };
+    /** The newest run, when it failed: when, and its error. */
+    failed?: {
+        runId: string;
+        at: number;
+        error: string;
+    };
+}
+/** A finished review in a few lines: when, its score, what it is about, the changes it asks for first. */
+export interface DashReviewSummary {
+    runId: string;
+    at: number;
+    analyzerName: string;
+    overall?: number;
+    /** Under the indicator set's line (70): a warning to coding agents. */
+    warning?: boolean;
+    /** What the reviewed thing is, as the review named it. */
+    title?: string;
+    /** The review's own summary, clipped — in a drawer's status (`review-status`), not in a list's marks. */
+    summary?: string;
+    /** How many changes it asks for, and the first three, most worth doing first. */
+    findings: number;
+    top: Array<{
+        priority: DashAiFinding['priority'];
+        title: string;
+    }>;
+    /** A statement reviewed only in an earlier version under its name: that version's id. */
+    of?: string;
+}
+/** `/api/ai/review-marks?kind=`: each target of a kind with a review or a run, by its id — a list's review chip. */
+export interface DashReviewMarks {
+    at: number;
+    kind: DashAiRun['target']['kind'];
+    marks: Record<string, DashReviewStatus>;
+}
 /** What became of a suggestion: new, accepted (for a coding agent to do), applied, or dismissed. */
 export type DashSuggestionState = 'new' | 'accepted' | 'applied' | 'dismissed';
 /**

package/lib/dashboard.js

@@ -1 +1 @@
-"use strict";export const DASHBOARD_PROTOCOL=1,DASH_PERF_KINDS=["n-plus-one","db-in-loop","render-storm","slow-path","slow-route","slow-query","missing-index","leak","egress-slow","duplicate-requests","perf-rule","other"];
+"use strict";export const DASHBOARD_PROTOCOL=1,DASH_PERF_KINDS=["n-plus-one","db-in-loop","render-storm","slow-path","slow-route","slow-query","missing-index","leak","egress-slow","duplicate-requests","perf-rule","db-connection","other"];

package/lib/event.d.ts

@@ -47,10 +47,10 @@ export declare const EventCategorySchema: z.ZodEnum<{
 }>;
 export type EventCategory = z.infer<typeof EventCategorySchema>;
 export declare const SeveritySchema: z.ZodEnum<{
+    error: "error";
     debug: "debug";
     info: "info";
     warning: "warning";
-    error: "error";
     fatal: "fatal";
 }>;
 export type Severity = z.infer<typeof SeveritySchema>;
@@ -104,10 +104,10 @@ export declare const BaseEventSchema: z.ZodObject<{
         agent: "agent";
     }>;
     severity: z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>;
     context: z.ZodObject<{

package/lib/resources.d.ts

@@ -14,18 +14,18 @@ export declare const ResourceEnvelopeSchema: z.ZodObject<{
 export type ResourceEnvelope = z.infer<typeof ResourceEnvelopeSchema>;
 export declare const AgentStatusKindSchema: z.ZodEnum<{
     warning: "warning";
-    starting: "starting";
     clean: "clean";
     failing: "failing";
+    starting: "starting";
 }>;
 export type AgentStatusKind = z.infer<typeof AgentStatusKindSchema>;
 export declare const AgentBlockingItemSchema: z.ZodObject<{
     source: z.ZodString;
     severity: z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>;
     title: z.ZodString;
@@ -50,36 +50,36 @@ export type AgentBlockingItem = z.infer<typeof AgentBlockingItemSchema>;
 export declare const AgentChecksSchema: z.ZodObject<{
     typecheck: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     lint: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     build: z.ZodOptional<z.ZodEnum<{
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     visual: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
     memory: z.ZodOptional<z.ZodEnum<{
         warning: "warning";
         unknown: "unknown";
-        failed: "failed";
         passed: "passed";
+        failed: "failed";
     }>>;
 }, z.core.$strip>;
 /**
@@ -114,19 +114,19 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     sessionId: z.ZodString;
     status: z.ZodEnum<{
         warning: "warning";
-        starting: "starting";
         clean: "clean";
         failing: "failing";
+        starting: "starting";
     }>;
     activeTab: z.ZodOptional<z.ZodString>;
     tabsWithIssues: z.ZodOptional<z.ZodArray<z.ZodString>>;
     blocking: z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -150,10 +150,10 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         severity: z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>;
         title: z.ZodString;
@@ -178,36 +178,36 @@ export declare const AgentCurrentStatusSchema: z.ZodObject<{
     checks: z.ZodOptional<z.ZodObject<{
         typecheck: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         lint: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         build: z.ZodOptional<z.ZodEnum<{
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         runtime: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         visual: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
         memory: z.ZodOptional<z.ZodEnum<{
             warning: "warning";
             unknown: "unknown";
-            failed: "failed";
             passed: "passed";
+            failed: "failed";
         }>>;
     }, z.core.$strip>>;
     server: z.ZodOptional<z.ZodObject<{
@@ -327,10 +327,10 @@ declare const CheckEntrySchema: z.ZodObject<{
     code: z.ZodOptional<z.ZodString>;
     rule: z.ZodOptional<z.ZodString>;
     severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
         debug: "debug";
         info: "info";
         warning: "warning";
-        error: "error";
         fatal: "fatal";
     }>>;
     file: z.ZodOptional<z.ZodString>;
@@ -356,9 +356,9 @@ export declare const TypecheckCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -395,9 +395,9 @@ export declare const TypecheckErrorsSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -416,10 +416,10 @@ export declare const TypecheckErrorsSchema: z.ZodObject<{
         code: z.ZodOptional<z.ZodString>;
         rule: z.ZodOptional<z.ZodString>;
         severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
             debug: "debug";
             info: "info";
             warning: "warning";
-            error: "error";
             fatal: "fatal";
         }>>;
         file: z.ZodOptional<z.ZodString>;
@@ -446,9 +446,9 @@ export declare const LintCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;
@@ -487,9 +487,9 @@ export declare const BuildCurrentSchema: z.ZodObject<{
         lastReportedAt: z.ZodNumber;
         lastRunStatus: z.ZodEnum<{
             error: "error";
+            running: "running";
             clean: "clean";
             failing: "failing";
-            running: "running";
         }>;
         lastRunDurationMs: z.ZodOptional<z.ZodNumber>;
         errorCount: z.ZodNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/protocol-types",
-  "version": "1.25.0",
+  "version": "1.25.2",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",