orcaq 1.1.1 → 1.1.2

package/.output/server/chunks/_/instance-insights.factory.mjs

@@ -1,7 +1,7 @@
-import { D as DatabaseClientType } from './db-connection.mjs';
+import { D as DatabaseClientType, d as getDatabaseSource } from './db-connection.mjs';
 import { c as createError } from '../nitro/nitro.mjs';
-import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
 import { c as createDatabaseHttpError } from './error.mjs';
+import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
 
 function getDatabaseLabel(dbType) {
   switch (dbType) {
@@ -29,6 +29,9 @@ class BaseUnsupportedInstanceInsightsAdapter {
       }
     });
   }
+  async getView() {
+    return this.unsupported("loading instance insights");
+  }
   async getDashboard() {
     return this.unsupported("loading dashboards");
   }
@@ -55,30 +58,1350 @@ class BaseUnsupportedInstanceInsightsAdapter {
   }
 }
 
+const DEFAULT_CAPABILITIES = {
+  supportsSessionInspection: false,
+  supportsLockInspection: false,
+  supportsConfiguration: false,
+  supportsReplication: false,
+  supportsDataGuard: false,
+  supportsStorageHealth: false,
+  supportsIntegrityChecks: false,
+  supportsMemoryLimits: false,
+  supportsCancelQuery: false,
+  supportsTerminateConnection: false,
+  supportsReplicationActions: false
+};
+function createInsightsCapabilities(overrides = {}) {
+  return {
+    ...DEFAULT_CAPABILITIES,
+    ...overrides
+  };
+}
+function createActionCapability(action) {
+  return action;
+}
+function createUnavailableSection(id, title, subtitle, statusMessage, capturedAt) {
+  return {
+    id,
+    title,
+    subtitle,
+    status: "unavailable",
+    statusMessage,
+    capturedAt,
+    tables: []
+  };
+}
+function toTitleLabel(key) {
+  return key.replace(/[._-]+/g, " ").replace(/([a-z\d])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function createColumns(keys) {
+  return keys.map((key) => ({
+    key,
+    label: toTitleLabel(key)
+  }));
+}
+function normalizeTableValue(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => item === null || item === void 0 ? "" : String(item)).filter(Boolean).join(", ");
+  }
+  return JSON.stringify(value);
+}
+function createTable(args) {
+  const rows = args.rows.map((row) => {
+    const normalized = {};
+    for (const [key, value] of Object.entries(row)) {
+      normalized[key] = normalizeTableValue(value);
+    }
+    return normalized;
+  });
+  const keys = args.columnKeys && args.columnKeys.length > 0 ? [...args.columnKeys] : Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
+  return {
+    id: args.id,
+    title: args.title,
+    description: args.description,
+    emptyMessage: args.emptyMessage,
+    columns: createColumns(keys),
+    rows
+  };
+}
+function formatNumber(value, digits = 0) {
+  const numeric = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+  if (!Number.isFinite(numeric)) {
+    return "-";
+  }
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: digits,
+    minimumFractionDigits: digits
+  }).format(numeric);
+}
+function formatPercent(value, digits = 1) {
+  const numeric = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+  if (!Number.isFinite(numeric)) {
+    return "-";
+  }
+  return `${formatNumber(numeric, digits)}%`;
+}
+function formatBytes(value) {
+  const numeric = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+  if (!Number.isFinite(numeric)) {
+    return "-";
+  }
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = Math.max(numeric, 0);
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+  const digits = unitIndex === 0 ? 0 : 2;
+  return `${formatNumber(size, digits)} ${units[unitIndex]}`;
+}
+function formatDateTime(value) {
+  if (!value) {
+    return "-";
+  }
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (Number.isNaN(date.getTime())) {
+    return String(value);
+  }
+  return date.toLocaleString();
+}
+function formatDurationSeconds(value) {
+  const numeric = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+  if (!Number.isFinite(numeric) || numeric < 0) {
+    return "-";
+  }
+  const totalSeconds = Math.round(numeric);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function formatBoolean(value) {
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  if (value === null || value === void 0) {
+    return "-";
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "on", "true", "yes"].includes(normalized)) {
+    return "Yes";
+  }
+  if (["0", "off", "false", "no"].includes(normalized)) {
+    return "No";
+  }
+  return String(value);
+}
+function formatValue(value) {
+  if (value === null || value === void 0 || value === "") {
+    return "-";
+  }
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  if (typeof value === "number") {
+    const digits = Number.isInteger(value) ? 0 : 2;
+    return formatNumber(value, digits);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => formatValue(item)).join(", ");
+  }
+  return String(value);
+}
+
 var __defProp$3 = Object.defineProperty;
 var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "" , value);
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+const IMPORTANT_VARIABLES = [
+  "max_connections",
+  "wait_timeout",
+  "interactive_timeout",
+  "innodb_buffer_pool_size",
+  "tmp_table_size",
+  "max_heap_table_size",
+  "sql_mode",
+  "read_only",
+  "super_read_only",
+  "performance_schema"
+];
 class MysqlInstanceInsightsAdapter extends BaseUnsupportedInstanceInsightsAdapter {
-  constructor(dbType) {
+  constructor(params) {
     super();
     __publicField$3(this, "dbType");
-    this.dbType = dbType;
+    __publicField$3(this, "adapter");
+    this.dbType = params.dbType;
+    this.adapter = params.adapter;
   }
   static async create(params, dbType = DatabaseClientType.MYSQL) {
-    return new MysqlInstanceInsightsAdapter(dbType);
+    const adapter = await getDatabaseSource({
+      ...params,
+      type: dbType
+    });
+    return new MysqlInstanceInsightsAdapter({
+      dbType,
+      adapter
+    });
+  }
+  async getView() {
+    var _a;
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const versionResult = await this.tryRawQuery(
+      "SELECT VERSION() AS version"
+    );
+    const version = versionResult.rows[0] ? String((_a = this.pick(versionResult.rows[0], "version")) != null ? _a : "") : null;
+    const [overview, sessions, configuration, replication] = await Promise.all([
+      this.buildOverviewSection(capturedAt, version),
+      this.buildSessionsSection(capturedAt),
+      this.buildConfigurationSection(capturedAt),
+      this.buildReplicationSection(capturedAt)
+    ]);
+    const sessionActions = [
+      createActionCapability({
+        id: "kill-query",
+        label: "Kill Query",
+        state: "supported",
+        description: `Cancel the active ${this.databaseLabel} query for a selected session.`
+      }),
+      createActionCapability({
+        id: "kill-connection",
+        label: "Kill Connection",
+        state: "supported",
+        description: `Terminate a selected ${this.databaseLabel} session.`
+      })
+    ];
+    const replicationActions = [
+      createActionCapability({
+        id: "replication-actions",
+        label: "Replication Actions",
+        state: "unsupported",
+        description: "Replication control actions are not exposed in phase 1."
+      })
+    ];
+    return {
+      dbType: this.dbType,
+      title: "Instance Insights",
+      databaseName: null,
+      version,
+      capturedAt,
+      capabilities: createInsightsCapabilities({
+        supportsSessionInspection: true,
+        supportsLockInspection: true,
+        supportsConfiguration: true,
+        supportsReplication: true,
+        supportsCancelQuery: true,
+        supportsTerminateConnection: true
+      }),
+      actions: [...sessionActions, ...replicationActions],
+      sections: [
+        overview,
+        {
+          ...sessions,
+          actions: sessionActions
+        },
+        configuration,
+        {
+          ...replication,
+          actions: replicationActions
+        }
+      ]
+    };
+  }
+  async cancelQuery(pid) {
+    this.ensurePositiveInteger(pid, "pid");
+    try {
+      await this.adapter.rawQuery(`KILL QUERY ${pid}`);
+      return {
+        success: true,
+        message: `Killed query for session ${pid}.`
+      };
+    } catch (error) {
+      throw createDatabaseHttpError(this.dbType, error);
+    }
+  }
+  async terminateConnection(pid) {
+    this.ensurePositiveInteger(pid, "pid");
+    try {
+      await this.adapter.rawQuery(`KILL CONNECTION ${pid}`);
+      return {
+        success: true,
+        message: `Terminated connection ${pid}.`
+      };
+    } catch (error) {
+      throw createDatabaseHttpError(this.dbType, error);
+    }
+  }
+  async buildOverviewSection(capturedAt, version) {
+    try {
+      const [statusRows, variableRows] = await Promise.all([
+        this.adapter.rawQuery("SHOW GLOBAL STATUS"),
+        this.adapter.rawQuery("SHOW GLOBAL VARIABLES")
+      ]);
+      const statusMap = this.toKeyValueMap(statusRows);
+      const variableMap = this.toKeyValueMap(variableRows);
+      const createdTmpTables = this.toNumber(statusMap.created_tmp_tables);
+      const createdTmpDiskTables = this.toNumber(
+        statusMap.created_tmp_disk_tables
+      );
+      const rollbackCount = this.toNumber(statusMap.com_rollback);
+      const commitCount = this.toNumber(statusMap.com_commit);
+      const bufferReadRequests = this.toNumber(
+        statusMap.innodb_buffer_pool_read_requests
+      );
+      const bufferReads = this.toNumber(statusMap.innodb_buffer_pool_reads);
+      const tempDiskRatio = createdTmpTables > 0 ? createdTmpDiskTables / createdTmpTables * 100 : 0;
+      const rollbackRatio = commitCount + rollbackCount > 0 ? rollbackCount / (commitCount + rollbackCount) * 100 : 0;
+      const bufferHitRatio = bufferReadRequests > 0 ? (bufferReadRequests - bufferReads) / bufferReadRequests * 100 : 100;
+      return {
+        id: "overview",
+        title: "Overview",
+        subtitle: `${this.databaseLabel} health and workload snapshot`,
+        status: "ready",
+        capturedAt,
+        cards: [
+          {
+            id: "version",
+            label: "Version",
+            value: version || "-"
+          },
+          {
+            id: "uptime",
+            label: "Uptime",
+            value: formatDurationSeconds(statusMap.uptime)
+          },
+          {
+            id: "threads-connected",
+            label: "Threads Connected",
+            value: formatNumber(statusMap.threads_connected),
+            helperText: `Running ${formatNumber(statusMap.threads_running)}`
+          },
+          {
+            id: "questions",
+            label: "Questions",
+            value: formatNumber(statusMap.questions),
+            helperText: `Connections ${formatNumber(statusMap.connections)}`
+          },
+          {
+            id: "slow-queries",
+            label: "Slow Queries",
+            value: formatNumber(statusMap.slow_queries),
+            helperText: `Aborted connects ${formatNumber(statusMap.aborted_connects)}`,
+            tone: this.toNumber(statusMap.slow_queries) > 0 ? "warning" : "default"
+          },
+          {
+            id: "temp-disk-ratio",
+            label: "Temp Disk Ratio",
+            value: formatPercent(tempDiskRatio, 2),
+            helperText: `Tmp tables ${formatNumber(createdTmpDiskTables)} on disk`,
+            tone: tempDiskRatio > 20 ? "warning" : "default"
+          },
+          {
+            id: "buffer-hit-ratio",
+            label: "InnoDB Buffer Hit Ratio",
+            value: formatPercent(bufferHitRatio, 2),
+            helperText: `Read requests ${formatNumber(bufferReadRequests)}`
+          },
+          {
+            id: "rollback-ratio",
+            label: "Rollback Ratio",
+            value: formatPercent(rollbackRatio, 2),
+            helperText: `Commits ${formatNumber(commitCount)} \xB7 Rollbacks ${formatNumber(rollbackCount)}`
+          }
+        ],
+        details: [
+          {
+            label: "Bytes Received",
+            value: formatBytes(statusMap.bytes_received)
+          },
+          {
+            label: "Bytes Sent",
+            value: formatBytes(statusMap.bytes_sent)
+          },
+          {
+            label: "Read Only",
+            value: formatBoolean(variableMap.read_only)
+          },
+          {
+            label: "Performance Schema",
+            value: formatBoolean(variableMap.performance_schema),
+            tone: formatBoolean(variableMap.performance_schema) === "No" ? "warning" : "default"
+          },
+          {
+            label: "Version Comment",
+            value: formatValue(variableMap.version_comment)
+          }
+        ]
+      };
+    } catch (error) {
+      return createUnavailableSection(
+        "overview",
+        "Overview",
+        `${this.databaseLabel} health and workload snapshot`,
+        this.getErrorMessage(error),
+        capturedAt
+      );
+    }
+  }
+  async buildSessionsSection(capturedAt) {
+    const processList = await this.tryRawQuery(
+      "SHOW FULL PROCESSLIST"
+    );
+    if (processList.error) {
+      return createUnavailableSection(
+        "sessions-locks",
+        "Sessions & Locks",
+        "Current sessions, waits, and lock pressure",
+        processList.error,
+        capturedAt
+      );
+    }
+    const notes = [];
+    const tables = [
+      createTable({
+        id: `${this.dbType}-sessions`,
+        title: "Sessions",
+        emptyMessage: "No sessions were returned.",
+        rows: processList.rows.map((row) => ({
+          session_id: this.pick(row, "Id", "id"),
+          user: this.pick(row, "User", "user"),
+          host: this.pick(row, "Host", "host"),
+          database: this.pick(row, "db", "DB"),
+          command: this.pick(row, "Command", "command"),
+          state: this.pick(row, "State", "state"),
+          duration_seconds: this.pick(row, "Time", "time"),
+          sql_text: this.pick(row, "Info", "info")
+        }))
+      })
+    ];
+    const lockWaits = await this.getLockWaitRows();
+    if (lockWaits.error) {
+      notes.push(lockWaits.error);
+    }
+    tables.push(
+      createTable({
+        id: `${this.dbType}-lock-waits`,
+        title: "Lock Waits",
+        emptyMessage: "No lock waits are currently visible.",
+        rows: lockWaits.rows
+      })
+    );
+    const metadataLocks = await this.getMetadataLockRows();
+    if (metadataLocks.error) {
+      notes.push(metadataLocks.error);
+    }
+    tables.push(
+      createTable({
+        id: `${this.dbType}-metadata-locks`,
+        title: "Metadata Locks",
+        emptyMessage: this.dbType === DatabaseClientType.MARIADB ? "Metadata lock info is unavailable unless the plugin is installed." : "Metadata lock details are unavailable unless instrumentation is enabled.",
+        rows: metadataLocks.rows
+      })
+    );
+    return {
+      id: "sessions-locks",
+      title: "Sessions & Locks",
+      subtitle: "Current sessions, waits, and lock pressure",
+      status: "ready",
+      capturedAt,
+      statusMessage: notes.length ? notes.join(" ") : null,
+      cards: [
+        {
+          id: "sessions-visible",
+          label: "Visible Sessions",
+          value: formatNumber(processList.rows.length)
+        },
+        {
+          id: "lock-waits",
+          label: "Lock Wait Rows",
+          value: formatNumber(lockWaits.rows.length)
+        },
+        {
+          id: "metadata-locks",
+          label: "Metadata Lock Rows",
+          value: formatNumber(metadataLocks.rows.length),
+          tone: metadataLocks.error ? "warning" : "default"
+        }
+      ],
+      tables
+    };
+  }
+  async buildConfigurationSection(capturedAt) {
+    const variablesResult = await this.tryRawQuery(
+      "SHOW GLOBAL VARIABLES"
+    );
+    if (variablesResult.error) {
+      return createUnavailableSection(
+        "configuration",
+        "Configuration",
+        `${this.databaseLabel} system variables`,
+        variablesResult.error,
+        capturedAt
+      );
+    }
+    const importantNames = new Set(IMPORTANT_VARIABLES);
+    const variableRows = variablesResult.rows.map((row) => {
+      const name = String(
+        this.pick(row, "Variable_name", "VARIABLE_NAME", "variable_name") || ""
+      );
+      const value = this.pick(row, "Value", "VALUE", "value");
+      return {
+        name,
+        category: importantNames.has(name) ? "Important" : "General",
+        value
+      };
+    }).sort((left, right) => {
+      if (left.category !== right.category) {
+        return left.category === "Important" ? -1 : 1;
+      }
+      return left.name.localeCompare(right.name);
+    });
+    const variableMap = this.toKeyValueMap(variablesResult.rows);
+    return {
+      id: "configuration",
+      title: "Configuration",
+      subtitle: `${this.databaseLabel} system variables`,
+      status: "ready",
+      capturedAt,
+      searchable: true,
+      searchPlaceholder: "Search variable name or value...",
+      cards: [
+        {
+          id: "variables-total",
+          label: "Variables",
+          value: formatNumber(variableRows.length)
+        },
+        {
+          id: "max-connections",
+          label: "Max Connections",
+          value: formatNumber(variableMap.max_connections)
+        },
+        {
+          id: "read-only",
+          label: "Read Only",
+          value: formatBoolean(variableMap.read_only)
+        },
+        {
+          id: "performance-schema",
+          label: "Performance Schema",
+          value: formatBoolean(variableMap.performance_schema),
+          tone: formatBoolean(variableMap.performance_schema) === "No" ? "warning" : "default"
+        }
+      ],
+      tables: [
+        createTable({
+          id: `${this.dbType}-configuration`,
+          title: "Variables",
+          emptyMessage: "No global variables were returned.",
+          rows: variableRows
+        })
+      ]
+    };
+  }
+  async buildReplicationSection(capturedAt) {
+    const replicaStatus = await this.getReplicaStatusRows();
+    const sourceReplicas = await this.getConnectedReplicasRows();
+    const notes = [];
+    if (replicaStatus.error) {
+      notes.push(replicaStatus.error);
+    }
+    if (sourceReplicas.error) {
+      notes.push(sourceReplicas.error);
+    }
+    const primaryReplicaRow = replicaStatus.rows[0] || {};
+    const lagValue = this.pick(
+      primaryReplicaRow,
+      "seconds_behind_source",
+      "seconds_behind_master",
+      "seconds_behind_primary"
+    );
+    const hasReplicationData = replicaStatus.rows.length > 0 || sourceReplicas.rows.length > 0;
+    if (!hasReplicationData && notes.length === 0) {
+      notes.push(
+        `${this.databaseLabel} replication is not configured or the current server is only acting as a primary/source.`
+      );
+    }
+    return {
+      id: "replication",
+      title: "Replication",
+      subtitle: `${this.databaseLabel} replica and source replication health`,
+      status: "ready",
+      capturedAt,
+      statusMessage: notes.length ? notes.join(" ") : null,
+      cards: [
+        {
+          id: "replica-status-rows",
+          label: "Replica Status Rows",
+          value: formatNumber(replicaStatus.rows.length)
+        },
+        {
+          id: "connected-replicas",
+          label: "Connected Replicas",
+          value: formatNumber(sourceReplicas.rows.length)
+        },
+        {
+          id: "replication-lag",
+          label: "Reported Lag",
+          value: formatValue(lagValue)
+        }
+      ],
+      tables: [
+        createTable({
+          id: `${this.dbType}-replica-status`,
+          title: "Replica Status",
+          emptyMessage: "No replica status rows were returned.",
+          rows: replicaStatus.rows
+        }),
+        createTable({
+          id: `${this.dbType}-connected-replicas`,
+          title: "Connected Replicas",
+          emptyMessage: "No connected replicas were returned.",
+          rows: sourceReplicas.rows
+        })
+      ]
+    };
+  }
+  async getLockWaitRows() {
+    if (this.dbType === DatabaseClientType.MARIADB) {
+      const result = await this.tryRawQuery(`
+        SELECT
+          trx_id AS transaction_id,
+          trx_state AS transaction_state,
+          trx_requested_lock_id AS waiting_lock_id,
+          trx_wait_started AS wait_started,
+          trx_mysql_thread_id AS thread_id,
+          trx_query AS query_text
+        FROM information_schema.innodb_trx
+        ORDER BY trx_wait_started DESC
+        LIMIT 200
+      `);
+      return {
+        rows: result.rows.map((row) => this.normalizeRowKeys(row)),
+        error: result.error
+      };
+    }
+    const sysResult = await this.tryRawQuery(`
+      SELECT
+        waiting_pid,
+        waiting_query,
+        blocking_pid,
+        blocking_query,
+        locked_table,
+        locked_index,
+        wait_age_secs
+      FROM sys.innodb_lock_waits
+      ORDER BY wait_age_secs DESC
+      LIMIT 200
+    `);
+    if (!sysResult.error) {
+      return {
+        rows: sysResult.rows.map((row) => this.normalizeRowKeys(row)),
+        error: null
+      };
+    }
+    const perfSchemaResult = await this.tryRawQuery(`
+      SELECT
+        requesting_engine_transaction_id AS waiting_transaction_id,
+        blocking_engine_transaction_id AS blocking_transaction_id,
+        requesting_thread_id AS waiting_thread_id,
+        blocking_thread_id AS blocking_thread_id
+      FROM performance_schema.data_lock_waits
+      LIMIT 200
+    `);
+    return {
+      rows: perfSchemaResult.rows.map((row) => this.normalizeRowKeys(row)),
+      error: perfSchemaResult.error
+    };
+  }
+  async getMetadataLockRows() {
+    if (this.dbType === DatabaseClientType.MARIADB) {
+      const result2 = await this.tryRawQuery(`
+        SELECT
+          thread_id,
+          lock_mode,
+          lock_type,
+          table_schema AS schema_name,
+          table_name
+        FROM information_schema.metadata_lock_info
+        LIMIT 200
+      `);
+      return {
+        rows: result2.rows.map((row) => this.normalizeRowKeys(row)),
+        error: result2.error ? "Metadata lock details are unavailable unless the MariaDB metadata lock plugin is installed." : null
+      };
+    }
+    const result = await this.tryRawQuery(`
+      SELECT
+        owner_thread_id AS thread_id,
+        lock_type,
+        lock_status,
+        object_schema AS schema_name,
+        object_name AS table_name
+      FROM performance_schema.metadata_locks
+      WHERE object_type = 'TABLE'
+      LIMIT 200
+    `);
+    return {
+      rows: result.rows.map((row) => this.normalizeRowKeys(row)),
+      error: result.error ? "Metadata lock details are unavailable unless performance_schema metadata instrumentation is enabled." : null
+    };
+  }
+  async getReplicaStatusRows() {
+    const queries = this.dbType === DatabaseClientType.MARIADB ? [
+      "SHOW ALL REPLICAS STATUS",
+      "SHOW REPLICA STATUS",
+      "SHOW SLAVE STATUS"
+    ] : ["SHOW REPLICA STATUS", "SHOW SLAVE STATUS"];
+    for (const query of queries) {
+      const result = await this.tryRawQuery(query);
+      if (!result.error) {
+        return {
+          rows: result.rows.map((row) => this.normalizeRowKeys(row)),
+          error: null
+        };
+      }
+    }
+    return {
+      rows: [],
+      error: `${this.databaseLabel} replication status is unavailable with the current privileges or server mode.`
+    };
+  }
+  async getConnectedReplicasRows() {
+    const queries = this.dbType === DatabaseClientType.MARIADB ? ["SHOW ALL REPLICAS STATUS"] : ["SHOW REPLICAS", "SHOW SLAVE HOSTS"];
+    for (const query of queries) {
+      const result = await this.tryRawQuery(query);
+      if (!result.error) {
+        return {
+          rows: result.rows.map((row) => this.normalizeRowKeys(row)),
+          error: null
+        };
+      }
+    }
+    return {
+      rows: [],
+      error: `${this.databaseLabel} source-side replica details are unavailable with the current privileges.`
+    };
+  }
+  async tryRawQuery(sql, bindings = []) {
+    try {
+      const rows = await this.adapter.rawQuery(sql, bindings);
+      return {
+        rows,
+        error: null
+      };
+    } catch (error) {
+      return {
+        rows: [],
+        error: this.getErrorMessage(error)
+      };
+    }
+  }
+  normalizeRowKeys(row) {
+    return Object.fromEntries(
+      Object.entries(row).map(([key, value]) => [this.toSnakeKey(key), value])
+    );
+  }
+  toKeyValueMap(rows) {
+    return rows.reduce((accumulator, row) => {
+      const key = this.pick(
+        row,
+        "Variable_name",
+        "VARIABLE_NAME",
+        "variable_name",
+        "name",
+        "NAME"
+      );
+      const value = this.pick(row, "Value", "VALUE", "value");
+      if (key !== null && key !== void 0) {
+        accumulator[String(key).toLowerCase()] = value;
+      }
+      return accumulator;
+    }, {});
+  }
+  pick(row, ...keys) {
+    for (const key of keys) {
+      if (key in row) {
+        return row[key];
+      }
+    }
+    return null;
+  }
+  toSnakeKey(value) {
+    return value.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").toLowerCase();
+  }
+  toNumber(value) {
+    const parsed = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  ensurePositiveInteger(value, field) {
+    if (!Number.isInteger(value) || value <= 0) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `${field} must be a positive integer`
+      });
+    }
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+      return error.message;
+    }
+    const candidate = error;
+    return String(
+      (candidate == null ? void 0 : candidate.message) || (candidate == null ? void 0 : candidate.statusMessage) || "Unknown database error"
+    );
+  }
+  get databaseLabel() {
+    return this.dbType === DatabaseClientType.MARIADB ? "MariaDB" : "MySQL";
   }
 }
 
 var __defProp$2 = Object.defineProperty;
 var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "" , value);
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
 class OracleInstanceInsightsAdapter extends BaseUnsupportedInstanceInsightsAdapter {
-  constructor() {
-    super(...arguments);
+  constructor(adapter) {
+    super();
     __publicField$2(this, "dbType", DatabaseClientType.ORACLE);
+    __publicField$2(this, "adapter");
+    this.adapter = adapter;
   }
   static async create(params) {
-    return new OracleInstanceInsightsAdapter();
+    const adapter = await getDatabaseSource({
+      ...params,
+      type: DatabaseClientType.ORACLE
+    });
+    return new OracleInstanceInsightsAdapter(adapter);
+  }
+  async getView() {
+    var _a, _b;
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const [overview, sessions, memoryLimits, configuration, dataGuard] = await Promise.all([
+      this.buildOverviewSection(capturedAt),
+      this.buildSessionsSection(capturedAt),
+      this.buildMemoryLimitsSection(capturedAt),
+      this.buildConfigurationSection(capturedAt),
+      this.buildDataGuardSection(capturedAt)
+    ]);
+    const version = (_b = (_a = overview.cards) == null ? void 0 : _a.find((card) => card.id === "version")) == null ? void 0 : _b.value;
+    return {
+      dbType: this.dbType,
+      title: "Instance Insights",
+      databaseName: null,
+      version: version && version !== "-" ? version : null,
+      capturedAt,
+      capabilities: createInsightsCapabilities({
+        supportsSessionInspection: true,
+        supportsLockInspection: true,
+        supportsConfiguration: true,
+        supportsDataGuard: true,
+        supportsMemoryLimits: true
+      }),
+      actions: [
+        createActionCapability({
+          id: "kill-session",
+          label: "Kill Session",
+          state: "unsupported",
+          description: "Oracle session termination is reserved for a later phase."
+        })
+      ],
+      sections: [overview, sessions, memoryLimits, configuration, dataGuard]
+    };
+  }
+  async buildOverviewSection(capturedAt) {
+    const instanceResult = await this.tryRawQuery(`
+      SELECT
+        instance_name,
+        host_name,
+        version,
+        startup_time,
+        status AS instance_status,
+        active_state,
+        instance_role
+      FROM v$instance
+    `);
+    if (instanceResult.error || !instanceResult.rows[0]) {
+      return createUnavailableSection(
+        "overview",
+        "Overview",
+        "Oracle instance state and throughput metrics",
+        instanceResult.error || "No Oracle instance details were returned.",
+        capturedAt
+      );
+    }
+    const metricsResult = await this.tryRawQuery(`
+      SELECT metric_name, value, metric_unit
+      FROM v$sysmetric
+      WHERE metric_name IN (
+        'Logical Reads Per Sec',
+        'Physical Reads Per Sec',
+        'Executions Per Sec',
+        'Redo Generated Per Sec',
+        'User Calls Per Sec'
+      )
+    `);
+    const instance = this.normalizeRowKeys(instanceResult.rows[0]);
+    const metrics = metricsResult.rows.map((row) => this.normalizeRowKeys(row));
+    const metricMap = metrics.reduce(
+      (accumulator, row) => {
+        const metricName = String(this.pick(row, "metric_name") || "");
+        accumulator[metricName] = this.pick(row, "value");
+        return accumulator;
+      },
+      {}
+    );
+    return {
+      id: "overview",
+      title: "Overview",
+      subtitle: "Oracle instance state and throughput metrics",
+      status: "ready",
+      capturedAt,
+      statusMessage: metricsResult.error,
+      cards: [
+        {
+          id: "instance-name",
+          label: "Instance",
+          value: formatValue(this.pick(instance, "instance_name"))
+        },
+        {
+          id: "status",
+          label: "Status",
+          value: formatValue(this.pick(instance, "instance_status"))
+        },
+        {
+          id: "active-state",
+          label: "Active State",
+          value: formatValue(this.pick(instance, "active_state"))
+        },
+        {
+          id: "role",
+          label: "Instance Role",
+          value: formatValue(this.pick(instance, "instance_role"))
+        },
+        {
+          id: "version",
+          label: "Version",
+          value: formatValue(this.pick(instance, "version"))
+        },
+        {
+          id: "logical-reads",
+          label: "Logical Reads/Sec",
+          value: formatNumber(metricMap["Logical Reads Per Sec"], 2)
+        },
+        {
+          id: "physical-reads",
+          label: "Physical Reads/Sec",
+          value: formatNumber(metricMap["Physical Reads Per Sec"], 2)
+        },
+        {
+          id: "executions",
+          label: "Executions/Sec",
+          value: formatNumber(metricMap["Executions Per Sec"], 2)
+        }
+      ],
+      details: [
+        {
+          label: "Host Name",
+          value: formatValue(this.pick(instance, "host_name"))
+        },
+        {
+          label: "Startup Time",
+          value: formatDateTime(this.pick(instance, "startup_time"))
+        },
+        {
+          label: "Redo Generated/Sec",
+          value: formatNumber(metricMap["Redo Generated Per Sec"], 2)
+        },
+        {
+          label: "User Calls/Sec",
+          value: formatNumber(metricMap["User Calls Per Sec"], 2)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "oracle-throughput-metrics",
+          title: "Throughput Metrics",
+          emptyMessage: "No throughput metrics were returned.",
+          rows: metrics
+        })
+      ]
+    };
+  }
+  async buildSessionsSection(capturedAt) {
+    const sessionsResult = await this.tryRawQuery(`
+      SELECT
+        sid,
+        serial# AS serial_number,
+        username,
+        machine,
+        program,
+        module,
+        event,
+        wait_class,
+        status
+      FROM v$session
+      WHERE type = 'USER'
+        AND ROWNUM <= 200
+    `);
+    if (sessionsResult.error) {
+      return createUnavailableSection(
+        "sessions-locks",
+        "Sessions & Locks",
+        "Oracle sessions, waits, and lock visibility",
+        sessionsResult.error,
+        capturedAt
+      );
+    }
+    const locksResult = await this.tryRawQuery(`
+      SELECT
+        sid,
+        type AS lock_type,
+        lmode AS held_mode,
+        request AS requested_mode,
+        block AS blocking_flag,
+        ctime AS lock_age_seconds
+      FROM v$lock
+      WHERE ROWNUM <= 200
+    `);
+    return {
+      id: "sessions-locks",
+      title: "Sessions & Locks",
+      subtitle: "Oracle sessions, waits, and lock visibility",
+      status: "ready",
+      capturedAt,
+      statusMessage: locksResult.error,
+      cards: [
+        {
+          id: "session-count",
+          label: "Visible Sessions",
+          value: formatNumber(sessionsResult.rows.length)
+        },
+        {
+          id: "lock-count",
+          label: "Visible Locks",
+          value: formatNumber(locksResult.rows.length)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "oracle-sessions",
+          title: "Sessions",
+          emptyMessage: "No Oracle sessions were returned.",
+          rows: sessionsResult.rows.map((row) => this.normalizeRowKeys(row))
+        }),
+        createTable({
+          id: "oracle-locks",
+          title: "Locks",
+          emptyMessage: "No Oracle locks were returned.",
+          rows: locksResult.rows.map((row) => this.normalizeRowKeys(row))
+        })
+      ]
+    };
+  }
+  async buildMemoryLimitsSection(capturedAt) {
+    const [sgaResult, pgaResult, limitResult] = await Promise.all([
+      this.tryRawQuery(`
+        SELECT name, value AS bytes
+        FROM v$sga
+      `),
+      this.tryRawQuery(`
+        SELECT name, value, unit
+        FROM v$pgastat
+        WHERE name IN (
+          'aggregate PGA target parameter',
+          'total PGA allocated',
+          'maximum PGA allocated'
+        )
+      `),
+      this.tryRawQuery(`
+        SELECT
+          resource_name,
+          current_utilization,
+          max_utilization,
+          limit_value
+        FROM v$resource_limit
+        WHERE resource_name IN ('sessions', 'processes', 'transactions')
+      `)
+    ]);
+    if (sgaResult.error && pgaResult.error && limitResult.error) {
+      return createUnavailableSection(
+        "memory-limits",
+        "Memory & Limits",
+        "SGA, PGA, and resource ceiling visibility",
+        sgaResult.error || pgaResult.error || limitResult.error || "Oracle memory views are unavailable.",
+        capturedAt
+      );
+    }
+    const sgaRows = sgaResult.rows.map((row) => this.normalizeRowKeys(row));
+    const pgaRows = pgaResult.rows.map((row) => this.normalizeRowKeys(row));
+    const limitRows = limitResult.rows.map((row) => this.normalizeRowKeys(row));
+    const totalSgaBytes = sgaRows.reduce(
+      (sum, row) => sum + this.toNumber(this.pick(row, "bytes")),
+      0
+    );
+    const totalPgaAllocated = pgaRows.find(
+      (row) => this.pick(row, "name") === "total PGA allocated"
+    );
+    const sessionsLimit = limitRows.find(
+      (row) => this.pick(row, "resource_name") === "sessions"
+    );
+    const sessionsLimitValue = this.pick(sessionsLimit || {}, "limit_value");
+    const sessionsUsage = this.toNumber(
+      this.pick(sessionsLimit || {}, "current_utilization")
+    );
+    const sessionsUsagePercent = this.toNumber(sessionsLimitValue) > 0 ? sessionsUsage / this.toNumber(sessionsLimitValue) * 100 : 0;
+    return {
+      id: "memory-limits",
+      title: "Memory & Limits",
+      subtitle: "SGA, PGA, and resource ceiling visibility",
+      status: "ready",
+      capturedAt,
+      statusMessage: [sgaResult.error, pgaResult.error, limitResult.error].filter(Boolean).join(" "),
+      cards: [
+        {
+          id: "total-sga",
+          label: "Total SGA",
+          value: formatBytes(totalSgaBytes)
+        },
+        {
+          id: "total-pga-allocated",
+          label: "Total PGA Allocated",
+          value: formatBytes(this.pick(totalPgaAllocated || {}, "value"))
+        },
+        {
+          id: "sessions-usage",
+          label: "Sessions Usage",
+          value: formatPercent(sessionsUsagePercent, 2),
+          helperText: `${formatNumber(sessionsUsage)} of ${formatValue(sessionsLimitValue)}`
+        }
+      ],
+      tables: [
+        createTable({
+          id: "oracle-sga",
+          title: "SGA Components",
+          emptyMessage: "No SGA component data was returned.",
+          rows: sgaRows.map((row) => ({
+            name: this.pick(row, "name"),
+            bytes: formatBytes(this.pick(row, "bytes"))
+          }))
+        }),
+        createTable({
+          id: "oracle-pga",
+          title: "PGA Statistics",
+          emptyMessage: "No PGA statistics were returned.",
+          rows: pgaRows.map((row) => ({
+            name: this.pick(row, "name"),
+            value: formatValue(this.pick(row, "value")),
+            unit: this.pick(row, "unit")
+          }))
+        }),
+        createTable({
+          id: "oracle-resource-limits",
+          title: "Resource Limits",
+          emptyMessage: "No resource limit rows were returned.",
+          rows: limitRows
+        })
+      ]
+    };
+  }
+  async buildConfigurationSection(capturedAt) {
+    const configurationResult = await this.tryRawQuery(`
+      SELECT
+        name,
+        display_value,
+        isdefault,
+        ismodified,
+        issys_modifiable,
+        isdeprecated,
+        description
+      FROM v$system_parameter
+      WHERE ROWNUM <= 1000
+      ORDER BY name
+    `);
+    if (configurationResult.error) {
+      return createUnavailableSection(
+        "configuration",
+        "Configuration",
+        "Oracle system parameter visibility",
+        configurationResult.error,
+        capturedAt
+      );
+    }
+    const rows = configurationResult.rows.map(
+      (row) => this.normalizeRowKeys(row)
+    );
+    return {
+      id: "configuration",
+      title: "Configuration",
+      subtitle: "Oracle system parameter visibility",
+      status: "ready",
+      capturedAt,
+      searchable: true,
+      searchPlaceholder: "Search parameter name or description...",
+      cards: [
+        {
+          id: "parameter-count",
+          label: "Parameters",
+          value: formatNumber(rows.length)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "oracle-configuration",
+          title: "System Parameters",
+          emptyMessage: "No system parameters were returned.",
+          rows
+        })
+      ]
+    };
+  }
+  async buildDataGuardSection(capturedAt) {
+    const [statsResult, archiveResult] = await Promise.all([
+      this.tryRawQuery(`
+        SELECT name, value, unit
+        FROM v$dataguard_stats
+      `),
+      this.tryRawQuery(`
+        SELECT
+          dest_id,
+          status,
+          destination,
+          target,
+          db_unique_name,
+          archiver,
+          process,
+          error,
+          recovery_mode,
+          protection_mode
+        FROM v$archive_dest_status
+        WHERE status <> 'INACTIVE'
+          AND ROWNUM <= 200
+      `)
+    ]);
+    const statsRows = statsResult.rows.map((row) => this.normalizeRowKeys(row));
+    const archiveRows = archiveResult.rows.map(
+      (row) => this.normalizeRowKeys(row)
+    );
+    if (statsRows.length === 0 && archiveRows.length === 0 && !statsResult.error && !archiveResult.error) {
+      return createUnavailableSection(
+        "data-guard",
+        "Data Guard",
+        "Standby and archive destination health",
+        "Data Guard metrics are empty. This database may not be running in a Data Guard topology.",
+        capturedAt
+      );
+    }
+    if (statsResult.error && archiveResult.error) {
+      return createUnavailableSection(
+        "data-guard",
+        "Data Guard",
+        "Standby and archive destination health",
+        `${statsResult.error} ${archiveResult.error}`.trim(),
+        capturedAt
+      );
+    }
+    const applyLagRow = statsRows.find(
+      (row) => this.pick(row, "name") === "apply lag"
+    );
+    return {
+      id: "data-guard",
+      title: "Data Guard",
+      subtitle: "Standby and archive destination health",
+      status: "ready",
+      capturedAt,
+      statusMessage: [statsResult.error, archiveResult.error].filter(Boolean).join(" "),
+      cards: [
+        {
+          id: "apply-lag",
+          label: "Apply Lag",
+          value: formatValue(this.pick(applyLagRow || {}, "value"))
+        },
+        {
+          id: "destinations",
+          label: "Archive Destinations",
+          value: formatNumber(archiveRows.length)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "oracle-dataguard-stats",
+          title: "Data Guard Stats",
+          emptyMessage: "No Data Guard stats were returned.",
+          rows: statsRows
+        }),
+        createTable({
+          id: "oracle-archive-destinations",
+          title: "Archive Destination Status",
+          emptyMessage: "No archive destination rows were returned.",
+          rows: archiveRows
+        })
+      ]
+    };
+  }
+  async tryRawQuery(sql, bindings = []) {
+    try {
+      const rows = await this.adapter.rawQuery(sql, bindings);
+      return {
+        rows,
+        error: null
+      };
+    } catch (error) {
+      return {
+        rows: [],
+        error: this.getErrorMessage(error)
+      };
+    }
+  }
+  normalizeRowKeys(row) {
+    return Object.fromEntries(
+      Object.entries(row).map(([key, value]) => [this.toSnakeKey(key), value])
+    );
+  }
+  pick(row, ...keys) {
+    for (const key of keys) {
+      if (key in row) {
+        return row[key];
+      }
+    }
+    return null;
+  }
+  toSnakeKey(value) {
+    return value.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").toLowerCase();
+  }
+  toNumber(value) {
+    const parsed = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+      return error.message;
+    }
+    const candidate = error;
+    return String(
+      (candidate == null ? void 0 : candidate.message) || (candidate == null ? void 0 : candidate.statusMessage) || "Unknown database error"
+    );
   }
 }
 
@@ -106,6 +1429,266 @@ class PostgresInstanceInsightsAdapter extends BaseDomainAdapter {
       cacheKey
     });
   }
+  async getView() {
+    const [dashboard, state, configuration, replication] = await Promise.all([
+      this.getDashboard(),
+      this.getState(),
+      this.getConfiguration(),
+      this.getReplication()
+    ]);
+    const sessionActions = [
+      createActionCapability({
+        id: "cancel-query",
+        label: "Cancel Query",
+        state: "supported",
+        description: "Cancel the selected backend query."
+      }),
+      createActionCapability({
+        id: "terminate-connection",
+        label: "Terminate Connection",
+        state: "supported",
+        description: "Terminate the selected backend connection."
+      })
+    ];
+    const replicationActions = [
+      createActionCapability({
+        id: "drop-replication-slot",
+        label: "Drop Replication Slot",
+        state: "supported",
+        description: "Drop stale replication slots from SQL context."
+      }),
+      createActionCapability({
+        id: "toggle-slot-status",
+        label: "Toggle Slot Status",
+        state: "conditional",
+        description: "Turning logical slots on is supported, while physical slot activation depends on replica clients."
+      })
+    ];
+    return {
+      dbType: this.dbType,
+      title: "Instance Insights",
+      databaseName: null,
+      version: dashboard.version || null,
+      capturedAt: dashboard.capturedAt,
+      capabilities: createInsightsCapabilities({
+        supportsSessionInspection: true,
+        supportsLockInspection: true,
+        supportsConfiguration: true,
+        supportsReplication: true,
+        supportsCancelQuery: true,
+        supportsTerminateConnection: true,
+        supportsReplicationActions: true
+      }),
+      actions: [...sessionActions, ...replicationActions],
+      sections: [
+        {
+          id: "overview",
+          title: "Overview",
+          subtitle: "PostgreSQL activity and workload summary",
+          status: "ready",
+          capturedAt: dashboard.capturedAt,
+          cards: [
+            {
+              id: "version",
+              label: "Version",
+              value: dashboard.version || "-"
+            },
+            {
+              id: "sessions-total",
+              label: "Total Sessions",
+              value: formatNumber(dashboard.sessions.total),
+              helperText: `Active ${formatNumber(dashboard.sessions.active)} \xB7 Idle ${formatNumber(dashboard.sessions.idle)}`,
+              tone: dashboard.sessions.exceedsThreshold ? "warning" : "default"
+            },
+            {
+              id: "tps",
+              label: "TPS",
+              value: formatNumber(dashboard.transactions.tps, 2),
+              helperText: `Commits ${formatNumber(dashboard.transactions.commitsPerSec, 2)}/s \xB7 Rollbacks ${formatNumber(dashboard.transactions.rollbacksPerSec, 2)}/s`
+            },
+            {
+              id: "buffer-hit-ratio",
+              label: "Buffer Hit Ratio",
+              value: formatPercent(dashboard.blockIO.bufferHitRatio, 2),
+              helperText: `Reads ${formatNumber(dashboard.blockIO.readsPerSec, 2)}/s \xB7 Hits ${formatNumber(dashboard.blockIO.hitsPerSec, 2)}/s`
+            }
+          ],
+          details: [
+            {
+              label: "Sampling Interval",
+              value: `${formatNumber(dashboard.intervalSeconds)}s`
+            },
+            {
+              label: "Connection Usage",
+              value: `${formatPercent(dashboard.sessions.usagePercent, 2)} of max_connections`,
+              tone: dashboard.sessions.exceedsThreshold ? "warning" : "default"
+            },
+            {
+              label: "Total Tuples Returned",
+              value: formatNumber(dashboard.tuples.totalReturned)
+            },
+            {
+              label: "Total Tuples Fetched",
+              value: formatNumber(dashboard.tuples.totalFetched)
+            }
+          ]
+        },
+        {
+          id: "sessions-locks",
+          title: "Sessions & Locks",
+          subtitle: "Active sessions, locks, and prepared transactions",
+          status: "ready",
+          capturedAt: state.capturedAt,
+          actions: sessionActions,
+          tables: [
+            createTable({
+              id: "postgres-sessions",
+              title: "Sessions",
+              emptyMessage: "No active sessions were returned.",
+              rows: state.sessions.map((row) => ({
+                pid: row.pid,
+                user: row.user,
+                application: row.application,
+                client: row.client,
+                state: row.state,
+                wait_event: row.waitEvent,
+                blocking_pids: row.blockingPids.join(", "),
+                backend_start: formatDateTime(row.backendStart),
+                transaction_start: formatDateTime(row.transactionStart),
+                query_start: formatDateTime(row.queryStart),
+                duration: formatDurationSeconds(row.durationSeconds),
+                sql: row.sql
+              }))
+            }),
+            createTable({
+              id: "postgres-locks",
+              title: "Locks",
+              emptyMessage: "No locks are currently visible.",
+              rows: state.locks.map((row) => ({
+                pid: row.pid,
+                lock_type: row.lockType,
+                target_relation: row.targetRelation,
+                mode: row.mode,
+                granted: row.granted,
+                state: row.state,
+                user: row.user,
+                sql: row.sql
+              }))
+            }),
+            createTable({
+              id: "postgres-prepared-transactions",
+              title: "Prepared Transactions",
+              emptyMessage: "No prepared transactions were returned.",
+              rows: state.preparedTransactions.map((row) => ({
+                transaction: row.transaction,
+                gid: row.gid,
+                prepared: formatDateTime(row.prepared),
+                owner: row.owner,
+                database: row.database
+              }))
+            })
+          ]
+        },
+        {
+          id: "configuration",
+          title: "Configuration",
+          subtitle: "Searchable PostgreSQL settings visibility",
+          status: "ready",
+          capturedAt: configuration.capturedAt,
+          searchable: true,
+          searchPlaceholder: "Search setting name, category, or description...",
+          cards: [
+            {
+              id: "configuration-total",
+              label: "Settings Returned",
+              value: formatNumber(configuration.rows.length),
+              helperText: `Total catalog rows ${formatNumber(configuration.total)}`
+            }
+          ],
+          tables: [
+            createTable({
+              id: "postgres-configuration",
+              title: "Settings",
+              emptyMessage: "No configuration settings were returned.",
+              rows: configuration.rows.map((row) => ({
+                name: row.name,
+                category: row.category,
+                value: row.value,
+                unit: row.unit,
+                pending_restart: row.pendingRestart,
+                description: row.description
+              }))
+            })
+          ]
+        },
+        {
+          id: "replication",
+          title: "Replication",
+          subtitle: "Replication clients and slot pressure",
+          status: "ready",
+          capturedAt: replication.capturedAt,
+          statusMessage: replication.staleSlotWarning,
+          actions: replicationActions,
+          cards: [
+            {
+              id: "replication-clients",
+              label: "Replication Clients",
+              value: formatNumber(replication.replicationStats.length)
+            },
+            {
+              id: "replication-slots",
+              label: "Replication Slots",
+              value: formatNumber(replication.replicationSlots.length)
+            },
+            {
+              id: "inactive-slots",
+              label: "Inactive Slots",
+              value: formatNumber(
+                replication.replicationSlots.filter((slot) => !slot.active).length
+              )
+            }
+          ],
+          tables: [
+            createTable({
+              id: "postgres-replication-stats",
+              title: "Replication Stats",
+              emptyMessage: "No replication clients are currently visible.",
+              rows: replication.replicationStats.map((row) => ({
+                pid: row.pid,
+                client_addr: row.clientAddr,
+                application_name: row.applicationName,
+                state: row.state,
+                sync_state: row.syncState,
+                reply_time: formatDateTime(row.replyTime),
+                write_lag: row.writeLag,
+                flush_lag: row.flushLag,
+                replay_lag: row.replayLag,
+                sent_lsn: row.sentLsn,
+                write_lsn: row.writeLsn,
+                flush_lsn: row.flushLsn,
+                replay_lsn: row.replayLsn
+              }))
+            }),
+            createTable({
+              id: "postgres-replication-slots",
+              title: "Replication Slots",
+              emptyMessage: "No replication slots are currently visible.",
+              rows: replication.replicationSlots.map((row) => ({
+                slot_name: row.slotName,
+                slot_type: row.slotType,
+                active: row.active,
+                active_pid: row.activePid,
+                restart_lsn: row.restartLsn,
+                confirmed_flush_lsn: row.confirmedFlushLsn,
+                retained_wal: formatBytes(row.retainedBytes),
+                temporary: row.temporary
+              }))
+            })
+          ]
+        }
+      ]
+    };
+  }
   async getDashboard() {
     var _a, _b;
     const [
@@ -714,14 +2297,454 @@ class PostgresInstanceInsightsAdapter extends BaseDomainAdapter {
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 class SqliteInstanceInsightsAdapter extends BaseUnsupportedInstanceInsightsAdapter {
-  constructor() {
-    super(...arguments);
+  constructor(adapter) {
+    super();
     __publicField(this, "dbType", DatabaseClientType.SQLITE3);
+    __publicField(this, "adapter");
+    this.adapter = adapter;
   }
   static async create(params) {
-    return new SqliteInstanceInsightsAdapter();
+    const adapter = await getDatabaseSource({
+      ...params,
+      type: DatabaseClientType.SQLITE3
+    });
+    return new SqliteInstanceInsightsAdapter(adapter);
+  }
+  async getView() {
+    var _a;
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const versionResult = await this.tryRawQuery(
+      "SELECT sqlite_version() AS version"
+    );
+    const version = versionResult.rows[0] ? String((_a = this.pick(versionResult.rows[0], "version")) != null ? _a : "") : null;
+    const [overview, storageHealth, configuration, integrity] = await Promise.all([
+      this.buildOverviewSection(capturedAt),
+      this.buildStorageHealthSection(capturedAt),
+      this.buildConfigurationSection(capturedAt),
+      this.buildIntegritySection(capturedAt)
+    ]);
+    return {
+      dbType: this.dbType,
+      title: "Instance Insights",
+      databaseName: null,
+      version,
+      capturedAt,
+      capabilities: createInsightsCapabilities({
+        supportsConfiguration: true,
+        supportsStorageHealth: true,
+        supportsIntegrityChecks: true
+      }),
+      actions: [
+        createActionCapability({
+          id: "checkpoint",
+          label: "Checkpoint",
+          state: "unsupported",
+          description: "Checkpoint controls are reserved for a later SQLite phase."
+        }),
+        createActionCapability({
+          id: "vacuum-recommendation",
+          label: "Vacuum Recommendation",
+          state: "conditional",
+          description: "Storage-health warnings highlight reclaimable space without running VACUUM automatically."
+        })
+      ],
+      sections: [overview, storageHealth, configuration, integrity]
+    };
+  }
+  async buildOverviewSection(capturedAt) {
+    const [
+      databaseList,
+      pageCount,
+      pageSize,
+      journalMode,
+      lockingMode,
+      autoVacuum
+    ] = await Promise.all([
+      this.tryRawQuery("PRAGMA database_list"),
+      this.tryRawQuery("PRAGMA page_count"),
+      this.tryRawQuery("PRAGMA page_size"),
+      this.tryRawQuery("PRAGMA journal_mode"),
+      this.tryRawQuery("PRAGMA locking_mode"),
+      this.tryRawQuery("PRAGMA auto_vacuum")
+    ]);
+    if (databaseList.error && pageCount.error && pageSize.error) {
+      return createUnavailableSection(
+        "overview",
+        "Overview",
+        "SQLite database/file shape and mode",
+        databaseList.error || pageCount.error || pageSize.error || "SQLite overview data is unavailable.",
+        capturedAt
+      );
+    }
+    const pageCountValue = this.toNumber(this.firstRowValue(pageCount.rows[0]));
+    const pageSizeValue = this.toNumber(this.firstRowValue(pageSize.rows[0]));
+    const approximateFileSize = pageCountValue * pageSizeValue;
+    const journalModeValue = this.firstRowValue(journalMode.rows[0]);
+    const lockingModeValue = this.firstRowValue(lockingMode.rows[0]);
+    const autoVacuumValue = this.firstRowValue(autoVacuum.rows[0]);
+    const dbRows = databaseList.rows.map((row) => this.normalizeRowKeys(row));
+    const mainDatabase = dbRows.find((row) => this.pick(row, "name") === "main");
+    return {
+      id: "overview",
+      title: "Overview",
+      subtitle: "SQLite database/file shape and mode",
+      status: "ready",
+      capturedAt,
+      statusMessage: [
+        databaseList.error,
+        pageCount.error,
+        pageSize.error,
+        journalMode.error,
+        lockingMode.error,
+        autoVacuum.error
+      ].filter(Boolean).join(" "),
+      cards: [
+        {
+          id: "page-count",
+          label: "Page Count",
+          value: formatNumber(pageCountValue)
+        },
+        {
+          id: "page-size",
+          label: "Page Size",
+          value: formatBytes(pageSizeValue)
+        },
+        {
+          id: "approx-size",
+          label: "Approx File Size",
+          value: formatBytes(approximateFileSize)
+        },
+        {
+          id: "journal-mode",
+          label: "Journal Mode",
+          value: formatValue(journalModeValue)
+        },
+        {
+          id: "locking-mode",
+          label: "Locking Mode",
+          value: formatValue(lockingModeValue)
+        },
+        {
+          id: "attached-databases",
+          label: "Attached Databases",
+          value: formatNumber(dbRows.length)
+        }
+      ],
+      details: [
+        {
+          label: "Main File Path",
+          value: formatValue(this.pick(mainDatabase || {}, "file"))
+        },
+        {
+          label: "Auto Vacuum",
+          value: this.describeAutoVacuum(autoVacuumValue)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "sqlite-database-list",
+          title: "Attached Databases",
+          emptyMessage: "No attached databases were returned.",
+          rows: dbRows
+        })
+      ]
+    };
+  }
+  async buildStorageHealthSection(capturedAt) {
+    const [freelistCount, pageSize, tableList, walAutocheckpoint, journalMode] = await Promise.all([
+      this.tryRawQuery("PRAGMA freelist_count"),
+      this.tryRawQuery("PRAGMA page_size"),
+      this.tryRawQuery("PRAGMA table_list"),
+      this.tryRawQuery("PRAGMA wal_autocheckpoint"),
+      this.tryRawQuery("PRAGMA journal_mode")
+    ]);
+    if (freelistCount.error && tableList.error) {
+      return createUnavailableSection(
+        "storage-health",
+        "Storage Health",
+        "Freelist, WAL, and table inventory visibility",
+        freelistCount.error || tableList.error || "SQLite storage health data is unavailable.",
+        capturedAt
+      );
+    }
+    const freelistValue = this.toNumber(
+      this.firstRowValue(freelistCount.rows[0])
+    );
+    const pageSizeValue = this.toNumber(this.firstRowValue(pageSize.rows[0]));
+    const reclaimableBytes = freelistValue * pageSizeValue;
+    const journalModeValue = String(
+      this.firstRowValue(journalMode.rows[0]) || ""
+    );
+    const walEnabled = journalModeValue.toLowerCase() === "wal";
+    const walAutocheckpointValue = this.firstRowValue(
+      walAutocheckpoint.rows[0]
+    );
+    const tableRows = tableList.rows.map((row) => this.normalizeRowKeys(row));
+    return {
+      id: "storage-health",
+      title: "Storage Health",
+      subtitle: "Freelist, WAL, and table inventory visibility",
+      status: "ready",
+      capturedAt,
+      statusMessage: [
+        freelistCount.error,
+        pageSize.error,
+        tableList.error,
+        walAutocheckpoint.error,
+        journalMode.error
+      ].filter(Boolean).join(" "),
+      cards: [
+        {
+          id: "freelist-count",
+          label: "Freelist Pages",
+          value: formatNumber(freelistValue)
+        },
+        {
+          id: "reclaimable-bytes",
+          label: "Reclaimable Bytes",
+          value: formatBytes(reclaimableBytes),
+          tone: reclaimableBytes > 0 ? "warning" : "default"
+        },
+        {
+          id: "wal-enabled",
+          label: "WAL Enabled",
+          value: walEnabled ? "Yes" : "No"
+        },
+        {
+          id: "table-count",
+          label: "Table Inventory",
+          value: formatNumber(tableRows.length)
+        }
+      ],
+      details: [
+        {
+          label: "WAL Auto-checkpoint",
+          value: formatValue(walAutocheckpointValue)
+        }
+      ],
+      tables: [
+        createTable({
+          id: "sqlite-table-list",
+          title: "Table Inventory",
+          emptyMessage: "No table inventory rows were returned.",
+          rows: tableRows
+        })
+      ],
+      checks: reclaimableBytes > 0 ? [
+        {
+          id: "reclaimable-space",
+          label: "Reclaimable Space Detected",
+          detail: `${formatBytes(reclaimableBytes)} can be reclaimed based on the current freelist count.`,
+          status: "warn",
+          tone: "warning"
+        }
+      ] : void 0
+    };
+  }
+  async buildConfigurationSection(capturedAt) {
+    var _a, _b;
+    const pragmaEntries = await Promise.all([
+      this.readPragmaEntry("foreign_keys", "PRAGMA foreign_keys"),
+      this.readPragmaEntry("synchronous", "PRAGMA synchronous"),
+      this.readPragmaEntry("mmap_size", "PRAGMA mmap_size"),
+      this.readPragmaEntry("cache_size", "PRAGMA cache_size"),
+      this.readPragmaEntry("query_only", "PRAGMA query_only"),
+      this.readPragmaEntry("read_uncommitted", "PRAGMA read_uncommitted"),
+      this.readPragmaEntry("trusted_schema", "PRAGMA trusted_schema")
+    ]);
+    const errors = pragmaEntries.map((entry) => entry.error).filter(Boolean);
+    const rows = pragmaEntries.filter((entry) => entry.value !== null).map((entry) => ({
+      name: entry.name,
+      value: entry.value
+    }));
+    if (!rows.length && errors.length) {
+      return createUnavailableSection(
+        "configuration",
+        "Configuration",
+        "SQLite PRAGMA settings",
+        errors.join(" "),
+        capturedAt
+      );
+    }
+    return {
+      id: "configuration",
+      title: "Configuration",
+      subtitle: "SQLite PRAGMA settings",
+      status: "ready",
+      capturedAt,
+      searchable: true,
+      searchPlaceholder: "Search PRAGMA name or value...",
+      statusMessage: errors.join(" "),
+      cards: [
+        {
+          id: "foreign-keys",
+          label: "Foreign Keys",
+          value: formatBoolean(
+            (_a = rows.find((row) => row.name === "foreign_keys")) == null ? void 0 : _a.value
+          )
+        },
+        {
+          id: "query-only",
+          label: "Query Only",
+          value: formatBoolean(
+            (_b = rows.find((row) => row.name === "query_only")) == null ? void 0 : _b.value
+          )
+        }
+      ],
+      tables: [
+        createTable({
+          id: "sqlite-configuration",
+          title: "PRAGMA Settings",
+          emptyMessage: "No PRAGMA settings were returned.",
+          rows
+        })
+      ]
+    };
+  }
+  async buildIntegritySection(capturedAt) {
+    const [quickCheck, integrityCheck] = await Promise.all([
+      this.tryRawQuery("PRAGMA quick_check"),
+      this.tryRawQuery("PRAGMA integrity_check")
+    ]);
+    if (quickCheck.error && integrityCheck.error) {
+      return createUnavailableSection(
+        "integrity",
+        "Integrity",
+        "Quick and full integrity checks",
+        `${quickCheck.error} ${integrityCheck.error}`.trim(),
+        capturedAt
+      );
+    }
+    const quickCheckValue = this.firstRowValue(quickCheck.rows[0]);
+    const integrityCheckValue = this.firstRowValue(integrityCheck.rows[0]);
+    const quickOk = String(quickCheckValue || "").toLowerCase() === "ok";
+    const integrityOk = String(integrityCheckValue || "").toLowerCase() === "ok";
+    return {
+      id: "integrity",
+      title: "Integrity",
+      subtitle: "Quick and full integrity checks",
+      status: "ready",
+      capturedAt,
+      statusMessage: [quickCheck.error, integrityCheck.error].filter(Boolean).join(" "),
+      cards: [
+        {
+          id: "quick-check",
+          label: "Quick Check",
+          value: formatValue(quickCheckValue),
+          tone: quickOk ? "success" : "warning"
+        },
+        {
+          id: "integrity-check",
+          label: "Integrity Check",
+          value: formatValue(integrityCheckValue),
+          tone: integrityOk ? "success" : "warning"
+        }
+      ],
+      checks: [
+        {
+          id: "quick-check-result",
+          label: "Quick Check Result",
+          detail: formatValue(quickCheckValue),
+          status: quickOk ? "pass" : "warn",
+          tone: quickOk ? "success" : "warning"
+        },
+        {
+          id: "integrity-check-result",
+          label: "Integrity Check Result",
+          detail: formatValue(integrityCheckValue),
+          status: integrityOk ? "pass" : "warn",
+          tone: integrityOk ? "success" : "warning"
+        }
+      ],
+      tables: [
+        createTable({
+          id: "sqlite-integrity-results",
+          title: "Integrity Results",
+          rows: [
+            {
+              check: "quick_check",
+              result: quickCheckValue
+            },
+            {
+              check: "integrity_check",
+              result: integrityCheckValue
+            }
+          ]
+        })
+      ]
+    };
+  }
+  async readPragmaEntry(name, sql) {
+    const result = await this.tryRawQuery(sql);
+    return {
+      name,
+      value: result.rows[0] ? this.firstRowValue(result.rows[0]) : null,
+      error: result.error
+    };
+  }
+  async tryRawQuery(sql, bindings = []) {
+    try {
+      const rows = await this.adapter.rawQuery(sql, bindings);
+      return {
+        rows,
+        error: null
+      };
+    } catch (error) {
+      return {
+        rows: [],
+        error: this.getErrorMessage(error)
+      };
+    }
+  }
+  normalizeRowKeys(row) {
+    return Object.fromEntries(
+      Object.entries(row).map(([key, value]) => [this.toSnakeKey(key), value])
+    );
+  }
+  firstRowValue(row) {
+    if (!row) {
+      return null;
+    }
+    const firstKey = Object.keys(row)[0];
+    return firstKey ? row[firstKey] : null;
+  }
+  pick(row, ...keys) {
+    for (const key of keys) {
+      if (key in row) {
+        return row[key];
+      }
+    }
+    return null;
+  }
+  toSnakeKey(value) {
+    return value.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").toLowerCase();
+  }
+  toNumber(value) {
+    const parsed = typeof value === "number" ? value : Number.parseFloat(String(value != null ? value : ""));
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  describeAutoVacuum(value) {
+    switch (String(value != null ? value : "")) {
+      case "0":
+        return "None";
+      case "1":
+        return "Full";
+      case "2":
+        return "Incremental";
+      default:
+        return formatValue(value);
+    }
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+      return error.message;
+    }
+    const candidate = error;
+    return String(
+      (candidate == null ? void 0 : candidate.message) || (candidate == null ? void 0 : candidate.statusMessage) || "Unknown database error"
+    );
   }
 }