@hienlh/ppm 0.19.1 → 0.19.3

package/src/web/components/chat/user-message-parse.ts

@@ -82,24 +82,46 @@ export function parseIdeOpenedFile(text: string): { idePath: string | null; clea
   return { idePath, cleanText };
 }
 
-/** Parse user message content, extracting attached file paths and the actual text */
+/**
+ * Parse user message content, extracting attached file paths and the actual text.
+ *
+ * Two markers mean the same thing to the reader and different things to the model. An image
+ * sent inline says so — the payload is already in the message, and a bare path would invite
+ * the model to spend a round trip opening what it was handed. Either way the path is what the
+ * chat draws a thumbnail from, so both forms have to be recognised here.
+ */
 export function parseUserAttachments(content: string): { files: string[]; text: string } {
-  // Match: [Attached file: /path] or [Attached files:\n/path1\n/path2\n]
-  // Trailing newlines are optional — an attachment-only message has the marker
-  // trimmed to the end of the string (extractTerminalBlocks trims), so the
-  // separator newlines may be absent.
-  const singleMatch = content.match(/^\[Attached file: (.+?)\]\n*/);
+  // Trailing newlines are optional — an attachment-only message has the marker trimmed to the
+  // end of the string (extractTerminalBlocks trims), so the separator newlines may be absent.
+  const files: string[] = [];
+  let rest = content;
+  for (;;) {
+    const inline = rest.match(/^\[Attached image \(contents included in this message\): (.+?)\]\n*/);
+    if (inline) {
+      files.push(inline[1]!);
+      rest = rest.slice(inline[0].length);
+      continue;
+    }
+    break;
+  }
+  if (files.length > 0) {
+    // A message may pair inline images with plain file attachments.
+    const tail = parseUserAttachments(rest);
+    return { files: [...files, ...tail.files], text: tail.text };
+  }
+
+  const singleMatch = rest.match(/^\[Attached file: (.+?)\]\n*/);
   if (singleMatch) {
-    return { files: [singleMatch[1]!], text: content.slice(singleMatch[0].length) };
+    return { files: [singleMatch[1]!], text: rest.slice(singleMatch[0].length) };
   }
 
-  const multiMatch = content.match(/^\[Attached files:\n([\s\S]+?)\]\n*/);
+  const multiMatch = rest.match(/^\[Attached files:\n([\s\S]+?)\]\n*/);
   if (multiMatch) {
-    const files = multiMatch[1]!.split("\n").map((l) => l.trim()).filter(Boolean);
-    return { files, text: content.slice(multiMatch[0].length) };
+    const list = multiMatch[1]!.split("\n").map((l) => l.trim()).filter(Boolean);
+    return { files: list, text: rest.slice(multiMatch[0].length) };
   }
 
-  return { files: [], text: content };
+  return { files: [], text: rest };
 }
 
 /** Extract leading terminal code fences from message text */

package/src/web/components/database/database-viewer.tsx

@@ -7,6 +7,7 @@ import { useConnections } from "./use-connections";
 import { SqlQueryEditor } from "./sql-query-editor";
 import { ExportButton } from "./export-button";
 import { GlideDataGrid } from "./glide-data-grid";
+import { extractQueryTable } from "./extract-query-table";
 import type { SchemaInfo } from "./sql-completion-provider";
 
 /** Parse WHERE "col" ILIKE '%val%' clauses from SQL */
@@ -140,6 +141,8 @@ export function DatabaseViewer({ metadata, tabId }: Props) {
 
   // Track whether user ran a custom query (show results instead of table grid)
   const [showingQueryResult, setShowingQueryResult] = useState(!!initialSql);
+  // SQL behind the currently displayed query result — tells us where to write edits back to
+  const [executedSql, setExecutedSql] = useState<string | null>(initialSql ?? null);
   const handleExecuteQuery = useCallback((sql: string) => {
     const trimmed = sql.trim();
     // Check if query is a simple SELECT on the current table — stay in table grid mode
@@ -154,6 +157,7 @@ export function DatabaseViewer({ metadata, tabId }: Props) {
       }
     }
     setShowingQueryResult(true);
+    setExecutedSql(trimmed);
     db.executeQuery(sql);
   }, [db.executeQuery, db.queryAsTable, db.selectedTable]);
 
@@ -171,6 +175,18 @@ export function DatabaseViewer({ metadata, tabId }: Props) {
     db.setPage(p);
   }, [db.setPage]);
 
+  // Ad-hoc query results are editable only when the result maps to one table and
+  // the connection allows writes — otherwise the grid stays read-only so edits
+  // can't pile up with nowhere to save them to.
+  const queryEditTable = useMemo(
+    () => (conn && !conn.readonly && executedSql ? extractQueryTable(executedSql, db.selectedSchema) : null),
+    [conn, executedSql, db.selectedSchema],
+  );
+  const handleQueryCellUpdate = useCallback((pkCol: string, pkVal: unknown, col: string, val: unknown) => {
+    if (!queryEditTable) return;
+    db.updateCellIn(queryEditTable.table, queryEditTable.schema, pkCol, pkVal, col, val);
+  }, [queryEditTable, db.updateCellIn]);
+
   const qr = db.queryResult;
   const showQueryResults = showingQueryResult && !!(qr || db.queryError);
   const showTableGrid = db.selectedTable && !showQueryResults;
@@ -246,7 +262,8 @@ export function DatabaseViewer({ metadata, tabId }: Props) {
           )}
 
           {showQueryResults && (
-            <QueryResultPanel result={qr} error={db.queryError} loading={db.queryLoading} schema={db.schema} connectionName={connectionName} />
+            <QueryResultPanel result={qr} error={db.queryError} loading={db.queryLoading} schema={db.schema}
+              connectionName={connectionName} onCellUpdate={queryEditTable ? handleQueryCellUpdate : undefined} />
           )}
 
           {showInitialLoading && (
@@ -262,27 +279,32 @@ export function DatabaseViewer({ metadata, tabId }: Props) {
 
 const NOOP = () => {};
 
-/** Read-only result panel for ad-hoc query results — uses DataGrid for SELECT to get checkboxes + export */
-function QueryResultPanel({ result, error, loading, schema, connectionName }: {
+/** Result panel for ad-hoc query results — uses DataGrid for SELECT to get checkboxes + export.
+ *  Editable only when the caller supplies onCellUpdate (single-table SELECT on a writable connection). */
+function QueryResultPanel({ result, error, loading, schema, connectionName, onCellUpdate }: {
   result: { columns: string[]; rows: Record<string, unknown>[]; rowsAffected: number; changeType: "select" | "modify"; executionTimeMs?: number } | null;
   error: string | null;
   loading?: boolean;
   schema?: DbColumnInfo[];
   connectionName?: string;
+  onCellUpdate?: (pkCol: string, pkVal: unknown, col: string, val: unknown) => void;
 }) {
-  // Build a read-only DataGrid-compatible tableData from query result
+  // Build a DataGrid-compatible tableData from query result
   const queryTableData = useMemo(() => (
     result?.changeType === "select" && result.rows.length > 0
       ? { columns: result.columns, rows: result.rows, total: result.rows.length, limit: result.rows.length }
       : null
   ), [result]);
 
-  // Use schema if available, otherwise build minimal schema from column names
-  const querySchema = useMemo(() => (
-    schema?.length ? schema : (result?.columns ?? []).map((c) => ({
-      name: c, type: "text", nullable: true, pk: false, defaultValue: null,
-    }))
-  ), [schema, result?.columns]);
+  // Use the sidebar table's schema only when it describes every result column —
+  // it belongs to the selected table, which may not be what the query returned.
+  // The grid drops columns missing from its schema, so a mismatch hides data.
+  const querySchema = useMemo(() => {
+    const cols = result?.columns ?? [];
+    const names = new Set((schema ?? []).map((c) => c.name));
+    if (schema?.length && cols.every((c) => names.has(c))) return schema;
+    return cols.map((c) => ({ name: c, type: "text", nullable: true, pk: false, defaultValue: null }));
+  }, [schema, result?.columns]);
 
   return (
     <div className="flex flex-col h-full overflow-hidden text-xs">
@@ -301,7 +323,8 @@ function QueryResultPanel({ result, error, loading, schema, connectionName }: {
             columns={queryTableData.columns} rows={queryTableData.rows}
             total={queryTableData.total} limit={queryTableData.limit}
             schema={querySchema} loading={!!loading}
-            page={1} onPageChange={NOOP} onCellUpdate={NOOP}
+            page={1} onPageChange={NOOP}
+            onCellUpdate={onCellUpdate ?? NOOP} readOnly={!onCellUpdate}
             orderBy={null} orderDir="ASC" onToggleSort={NOOP}
             connectionName={connectionName}
           />

package/src/web/components/database/extract-query-table.ts

@@ -0,0 +1,24 @@
+/**
+ * The single table an ad-hoc SELECT reads from, or null when its rows can't be
+ * mapped back to one table (JOIN, set operation, subquery, aggregate).
+ *
+ * Editing a query result writes an UPDATE against this table, so anything
+ * ambiguous must return null — the grid then stays read-only instead of
+ * collecting edits that have nowhere to go.
+ */
+export function extractQueryTable(sql: string, defaultSchema: string): { table: string; schema: string } | null {
+  const stripped = sql
+    .replace(/--[^\r\n]*/g, " ")
+    .replace(/\/\*[\s\S]*?\*\//g, " ")
+    .trim()
+    .replace(/;\s*$/, "");
+  if (!/^select\s/i.test(stripped)) return null;
+  if (/\b(join|union|intersect|except|group\s+by|distinct)\b/i.test(stripped)) return null;
+  // More than one FROM means a subquery or derived table is involved.
+  if ((stripped.match(/\bfrom\b/gi) ?? []).length !== 1) return null;
+  const m = /\bfrom\s+(?:"([^"]+)"|(\w+))\s*(?:\.\s*(?:"([^"]+)"|(\w+)))?/i.exec(stripped);
+  if (!m) return null;
+  const first = m[1] ?? m[2]!;
+  const second = m[3] ?? m[4];
+  return second ? { schema: first, table: second } : { table: first, schema: defaultSchema };
+}

package/src/web/components/database/glide-data-grid.tsx

@@ -16,6 +16,9 @@ import { GlideSaveBar } from "./glide-save-bar";
 import { GlideGridPagination } from "./glide-grid-pagination";
 import { GlideDataPreviewPanel } from "./glide-data-preview-panel";
 
+/** Swallows edits (paste, context-menu actions) while the grid is read-only. */
+const NOOP_EDIT = () => {};
+
 const HEADER_ICONS: Record<string, (p: { fgColor: string }) => string> = {
   sortAsc: (p) => `<svg viewBox="0 0 16 16" fill="${p.fgColor}"><path d="M8 4l4 6H4z"/></svg>`,
   sortDesc: (p) => `<svg viewBox="0 0 16 16" fill="${p.fgColor}"><path d="M8 12l4-6H4z"/></svg>`,
@@ -31,7 +34,7 @@ export function GlideDataGrid(props: GlideGridProps) {
     columns: rawColumnNames, rows, total, limit, schema, loading,
     page, onPageChange, onCellUpdate, onRowDelete, onBulkDelete, onInsertRow,
     orderBy, orderDir, onToggleSort, onClearSort, columnFilters = {}, onColumnFilter,
-    connectionId, selectedTable, selectedSchema, connectionName,
+    connectionId, selectedTable, selectedSchema, connectionName, readOnly,
   } = props;
 
   const theme = useGlideTheme();
@@ -78,14 +81,18 @@ export function GlideDataGrid(props: GlideGridProps) {
   }, [pinnedCount, pkCol, searchTerm, displayRows, pinnedPks]);
 
   // Hooks
+  // Without a primary key there is no way to address a row in an UPDATE, so
+  // edits could never be saved — don't let the user make them in the first place.
+  const cellsReadOnly = !!readOnly || !pkCol;
+
   const { pendingRef, addEdit, commitAll, discardAll, hasPending, pendingCount, committedRef } = useGlidePendingEdits(pkCol, onCellUpdate, onInsertRow);
   const { columns, freezeColumns, columnOrder } = useGlideColumns(schema, columnNames, pinnedCols, colWidths, displayRows, orderBy, orderDir);
-  const { getCellContent, onCellEdited } = useGlideCellContent(displayRows, columnOrder, schema, pkCol, addEdit, pendingRef);
+  const { getCellContent, onCellEdited } = useGlideCellContent(displayRows, columnOrder, schema, pkCol, addEdit, pendingRef, cellsReadOnly);
   const { gridSelection, onGridSelectionChange, selectedRowIndices, clearSelection } = useGlideSelection();
   const {
     previewData, closePreview, openRowPreview, openCellPreview, openPreviewInTab,
     handlePaste, getContextFk, isCellViewable, openFkTable,
-  } = useGlideGridActions({ displayRows, columnOrder, schema, pkCol, connectionId, connectionName, selectedTable, selectedSchema, addEdit, gridSelection, containerRef });
+  } = useGlideGridActions({ displayRows, columnOrder, schema, pkCol, connectionId, connectionName, selectedTable, selectedSchema, addEdit: cellsReadOnly ? NOOP_EDIT : addEdit, gridSelection, containerRef });
 
   useEffect(() => {
     if (committedRef.current) { committedRef.current = false; discardAll(); setInsertedRows([]); }
@@ -166,7 +173,7 @@ export function GlideDataGrid(props: GlideGridProps) {
       <div className="flex-1 min-h-0">
         <DataEditor ref={gridRef} columns={columns} rows={displayRows.length}
           getCellContent={getCellContent} getCellsForSelection={true}
-          onCellEdited={onCellEdited} onPaste={handlePaste}
+          onCellEdited={onCellEdited} onPaste={cellsReadOnly ? false : handlePaste}
           theme={theme} freezeColumns={freezeColumns} freezeTrailingRows={frozenTrailingRows}
           rowMarkers={pkCol ? "checkbox-visible" : "number"}
           gridSelection={gridSelection} onGridSelectionChange={onGridSelectionChange}

package/src/web/components/database/glide-grid-types.ts

@@ -29,6 +29,10 @@ export interface GlideGridProps {
   onPageChange: (page: number) => void;
   /** Cell edit: (pkColumn, pkValue, editedColumn, newValue) */
   onCellUpdate: (pkCol: string, pkVal: unknown, col: string, val: unknown) => void;
+  /** Block all cell editing — cells stay viewable/copyable but cannot be changed.
+   *  Set when there is nowhere to write the edit back to (ad-hoc query results
+   *  whose source table can't be determined, readonly connections). */
+  readOnly?: boolean;
   onRowDelete?: (pkCol: string, pkVal: unknown) => void;
   onBulkDelete?: (pkCol: string, pkValues: unknown[]) => void;
   onInsertRow?: (values: Record<string, unknown>) => Promise<void>;

package/src/web/components/database/split-sql-statements.ts

@@ -0,0 +1,116 @@
+export interface SqlStatement {
+  /** Statement text from its first token through its terminating semicolon. */
+  sql: string;
+  /** 1-based line of the statement's first token (blank/comment lines skipped). */
+  startLine: number;
+  /** 1-based line the statement ends on. */
+  endLine: number;
+}
+
+const IDENT_CHAR = /[A-Za-z0-9_]/;
+const DOLLAR_TAG = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/;
+
+/**
+ * Split SQL into statements on top-level semicolons.
+ *
+ * A semicolon only terminates a statement when it is not inside a string, a
+ * quoted identifier, a comment, or a dollar-quoted block — so a trailing
+ * `-- comment` after the semicolon, or a `;` inside a literal, no longer glues
+ * two statements together.
+ */
+export function splitSqlStatements(text: string): SqlStatement[] {
+  const statements: SqlStatement[] = [];
+  let line = 1;
+  let firstTokenIdx = -1;
+  let firstTokenLine = 1;
+  let i = 0;
+
+  const flush = (endIdx: number, endLine: number) => {
+    if (firstTokenIdx === -1) return;
+    const sql = text.slice(firstTokenIdx, endIdx).trim();
+    if (sql) statements.push({ sql, startLine: firstTokenLine, endLine });
+    firstTokenIdx = -1;
+  };
+
+  while (i < text.length) {
+    const ch = text[i]!;
+
+    if (ch === "\n") { line++; i++; continue; }
+    if (ch === " " || ch === "\t" || ch === "\r") { i++; continue; }
+
+    // Line comment — runs to end of line, never part of a statement's start
+    if (ch === "-" && text[i + 1] === "-") {
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+
+    // Block comment — Postgres allows these to nest
+    if (ch === "/" && text[i + 1] === "*") {
+      let depth = 1;
+      i += 2;
+      while (i < text.length && depth > 0) {
+        if (text[i] === "/" && text[i + 1] === "*") { depth++; i += 2; continue; }
+        if (text[i] === "*" && text[i + 1] === "/") { depth--; i += 2; continue; }
+        if (text[i] === "\n") line++;
+        i++;
+      }
+      continue;
+    }
+
+    if (firstTokenIdx === -1) { firstTokenIdx = i; firstTokenLine = line; }
+
+    if (ch === ";") { flush(i + 1, line); i++; continue; }
+
+    // String literal or quoted identifier
+    if (ch === "'" || ch === '"') {
+      // E'...' honours backslash escapes; plain strings only double the quote
+      const prev = text[i - 1];
+      const prev2 = text[i - 2];
+      const escapes = ch === "'" && (prev === "e" || prev === "E") && !(prev2 !== undefined && IDENT_CHAR.test(prev2));
+      i++;
+      while (i < text.length) {
+        const c = text[i]!;
+        if (c === "\n") { line++; i++; continue; }
+        if (escapes && c === "\\") { i += 2; continue; }
+        if (c === ch) {
+          if (text[i + 1] === ch) { i += 2; continue; } // doubled quote = literal
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+
+    // Dollar-quoted block ($$ … $$ / $tag$ … $tag$) — bodies hold their own semicolons
+    if (ch === "$") {
+      const m = DOLLAR_TAG.exec(text.slice(i));
+      if (m) {
+        const tag = m[0];
+        const close = text.indexOf(tag, i + tag.length);
+        const stop = close === -1 ? text.length : close + tag.length;
+        for (let k = i; k < stop; k++) if (text[k] === "\n") line++;
+        i = stop;
+        continue;
+      }
+    }
+
+    i++;
+  }
+
+  flush(text.length, line);
+  return statements;
+}
+
+/**
+ * The statement the cursor sits in. Falls back to the next statement below the
+ * cursor (cursor parked on a blank line between statements), then to the last.
+ */
+export function getStatementAtCursor(text: string, cursorLine: number): string {
+  const statements = splitSqlStatements(text);
+  if (statements.length === 0) return "";
+  const containing = statements.find((s) => s.startLine <= cursorLine && cursorLine <= s.endLine);
+  if (containing) return containing.sql;
+  const following = statements.find((s) => s.startLine > cursorLine);
+  return (following ?? statements[statements.length - 1]!).sql;
+}

package/src/web/components/database/sql-completion-provider.ts

@@ -1,4 +1,5 @@
 import type * as MonacoType from "monaco-editor";
+import { getStatementAtCursor } from "./split-sql-statements";
 
 export interface SchemaInfo {
   tables: { name: string; schema: string }[];
@@ -22,32 +23,6 @@ export const AGGREGATE_FNS = ["COUNT", "SUM", "AVG", "MIN", "MAX"];
 export const OPERATORS = ["=", "!=", "<>", ">", "<", ">=", "<=", "LIKE", "ILIKE", "IN", "NOT IN", "BETWEEN", "IS NULL", "IS NOT NULL"];
 export const SORT_DIRS = ["ASC", "DESC"];
 
-/** Find the SQL statement surrounding the cursor line (split by ;) */
-export function getStatementAtCursor(text: string, cursorLine: number): string {
-  const lines = text.split("\n");
-  let stmtStart = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i]!.trim();
-    if (i < cursorLine - 1 && trimmed.endsWith(";")) {
-      stmtStart = i + 1;
-    }
-  }
-  let stmtEnd = lines.length - 1;
-  for (let i = cursorLine - 1; i < lines.length; i++) {
-    const trimmed = lines[i]!.trim();
-    if (trimmed.endsWith(";")) {
-      stmtEnd = i;
-      break;
-    }
-  }
-  while (stmtStart <= stmtEnd) {
-    const t = lines[stmtStart]!.trim();
-    if (t && !t.startsWith("--")) break;
-    stmtStart++;
-  }
-  return lines.slice(stmtStart, stmtEnd + 1).join("\n").trim();
-}
-
 /** Client-side column cache to avoid redundant fetches */
 const columnCache = new Map<string, { name: string; type: string }[]>();
 

package/src/web/components/database/sql-query-editor.tsx

@@ -2,7 +2,8 @@ import { useState, useCallback, useRef, useEffect } from "react";
 import Editor, { type OnMount } from "@monaco-editor/react";
 import type * as MonacoType from "monaco-editor";
 import { useMonacoTheme } from "@/lib/use-monaco-theme";
-import { createSqlCompletionProvider, clearCompletionCache, getStatementAtCursor, type SchemaInfo } from "./sql-completion-provider";
+import { createSqlCompletionProvider, clearCompletionCache, type SchemaInfo } from "./sql-completion-provider";
+import { getStatementAtCursor } from "./split-sql-statements";
 
 interface SqlQueryEditorProps {
   onExecute: (sql: string) => void;

package/src/web/components/database/use-database.ts

@@ -232,12 +232,27 @@ export function useDatabase(connectionId: number) {
     fetchTableData();
   }, [executeQuery, queryAsTable, fetchTableData]);
 
+  /** Update a cell in an explicitly named table, then reload the current view.
+   *  Used by ad-hoc query results, where the target table comes from the SQL
+   *  rather than the sidebar selection. */
+  const updateCellIn = useCallback(async (
+    table: string, tableSchema: string,
+    pkColumn: string, pkValue: unknown, column: string, value: unknown,
+  ) => {
+    try {
+      await api.put(`${base}/cell`, { table, schema: tableSchema, pkColumn, pkValue, column, value });
+      reload();
+    } catch (e) {
+      failMutation("Update cell", e);
+    }
+  }, [base, reload, failMutation]);
+
   return {
     selectedTable, selectedSchema, selectTable, tableData, schema,
     loading, error, page, setPage: changePage,
     orderBy, orderDir, toggleSort, clearSort,
     queryResult, queryError, queryLoading, executeQuery,
-    updateCell, deleteRow, bulkDelete, insertRow,
+    updateCell, updateCellIn, deleteRow, bulkDelete, insertRow,
     refreshData: fetchTableData, queryAsTable, reload,
   };
 }

package/src/web/components/database/use-glide-cell-content.ts

@@ -49,7 +49,12 @@ export function useGlideCellContent(
   pkCol: string | null,
   addPendingEdit: (pkVal: unknown, col: string, newVal: unknown) => void,
   pendingRef: React.RefObject<Map<string, PendingEdit>>,
+  readOnly = false,
 ): UseGlideCellContentResult {
+  // Read through a ref: getCellContent is stable (canvas render loop) and must
+  // still see the current mode without being re-created.
+  const readOnlyRef = useRef(readOnly);
+  readOnlyRef.current = readOnly;
   const rowsRef = useRef(rows);
   rowsRef.current = rows;
   const colOrderRef = useRef(columnOrder);
@@ -106,7 +111,7 @@ export function useGlideCellContent(
       }
       return {
         kind: GridCellKind.Text, data: "", displayData: placeholder,
-        allowOverlay: !isPk, readonly: isPk,
+        allowOverlay: !isPk, readonly: isPk || readOnlyRef.current,
         themeOverride: hasPending ? PENDING_THEME : (isNewRow || placeholder !== "NULL" ? { textDark: "#9ca3af" } : { textDark: "#6b7280" }),
       };
     }
@@ -115,27 +120,27 @@ export function useGlideCellContent(
     if (kind === GridCellKind.Number && typeof val === "number") {
       return {
         kind: GridCellKind.Number, data: val, displayData: String(val),
-        allowOverlay: !isPk, readonly: isPk,
+        allowOverlay: !isPk, readonly: isPk || readOnlyRef.current,
         themeOverride: hasPending ? PENDING_THEME : undefined,
       };
     }
 
     // Boolean cells
     if (kind === GridCellKind.Boolean && typeof val === "boolean") {
-      return { kind: GridCellKind.Boolean, data: val, readonly: isPk, allowOverlay: false };
+      return { kind: GridCellKind.Boolean, data: val, readonly: isPk || readOnlyRef.current, allowOverlay: false };
     }
 
     // Text cell
     const strVal = formatCellValue(val);
     return {
       kind: GridCellKind.Text, data: strVal, displayData: truncateDisplay(strVal),
-      allowOverlay: !isPk, readonly: isPk,
+      allowOverlay: !isPk, readonly: isPk || readOnlyRef.current,
       themeOverride: hasPending ? PENDING_THEME : undefined,
     };
   }, []); // stable — reads from refs
 
   const onCellEdited = useCallback(([colIdx, rowIdx]: Item, newValue: EditableGridCell) => {
-    if (!pkCol) return;
+    if (!pkCol || readOnly) return;
     const colName = colOrderRef.current[colIdx];
     const row = rowsRef.current[rowIdx];
     if (!colName || !row) return;
@@ -153,7 +158,7 @@ export function useGlideCellContent(
     }
 
     addPendingEdit(pkVal, colName, parsed);
-  }, [pkCol, addPendingEdit]);
+  }, [pkCol, readOnly, addPendingEdit]);
 
   return { getCellContent, onCellEdited };
 }

package/src/web/components/editor/code-editor.tsx

@@ -14,7 +14,8 @@ import { EditorToolbar } from "./editor-toolbar";
 import { EditorLanguagePicker } from "./editor-language-picker";
 import { SaveAsDialog } from "./save-as-dialog";
 import { EditorMobileToolbar } from "./editor-mobile-toolbar";
-import { createSqlCompletionProvider, clearCompletionCache, getStatementAtCursor, type SchemaInfo } from "../database/sql-completion-provider";
+import { createSqlCompletionProvider, clearCompletionCache, type SchemaInfo } from "../database/sql-completion-provider";
+import { getStatementAtCursor, splitSqlStatements } from "../database/split-sql-statements";
 import { useConnections, type Connection } from "../database/use-connections";
 import { GlideDataGrid } from "../database/glide-data-grid";
 import type { GridColumnSchema } from "../database/glide-grid-types";
@@ -509,76 +510,49 @@ export const CodeEditor = memo(function CodeEditor({ metadata, tabId }: CodeEdit
             if (model !== thisModel) return { lenses: [], dispose: () => {} };
 
             const lenses: MonacoType.languages.CodeLens[] = [];
-            const text = model.getValue();
-            const lines = text.split("\n");
-            let stmtStartLine = -1;
-            let stmtLines: string[] = [];
-            let dollarBlock = false; // Track DO $$ ... $$ blocks
-
-            // Transaction block tracking: group BEGIN...COMMIT into single Run Transaction
-            const txPattern = /^(BEGIN|COMMIT|ROLLBACK|END)(;|\s|$)/i;
-            let txBlockStartLine = -1;
-            let txBlockStmts: string[] = [];
 
             const addLens = (line: number, stmt: string, title = "\u25B7 Run") => {
               const trimmed = stmt.trim();
-              if (!trimmed || trimmed.startsWith("--")) return;
+              if (!trimmed) return;
               lenses.push({
                 range: { startLineNumber: line, startColumn: 1, endLineNumber: line, endColumn: 1 },
                 command: { id: cmdId, title, arguments: [trimmed] },
               });
             };
 
-            for (let i = 0; i < lines.length; i++) {
-              const trimmed = lines[i]!.trim();
-              if (stmtStartLine === -1) {
-                if (!trimmed || trimmed.startsWith("--")) continue;
-                stmtStartLine = i + 1;
-                stmtLines = [];
-              }
-              stmtLines.push(lines[i]!);
-
-              // Detect $$ dollar-quoted block start/end
-              const dollarMatches = (trimmed.match(/\$\$/g) || []).length;
-              if (dollarMatches % 2 === 1) dollarBlock = !dollarBlock;
-
-              // Only split on ; when NOT inside a $$ block
-              if (!dollarBlock && trimmed.endsWith(";")) {
-                const stmt = stmtLines.join("\n").trim();
-                const isTxStart = /^BEGIN(;|\s|$)/i.test(stmt);
-                const isTxEnd = /^(COMMIT|ROLLBACK|END)(;|\s|$)/i.test(stmt);
-
-                if (txBlockStartLine === -1 && isTxStart) {
-                  // Start collecting transaction block
-                  txBlockStartLine = stmtStartLine;
-                  txBlockStmts = [stmt];
-                } else if (txBlockStartLine > -1) {
-                  txBlockStmts.push(stmt);
-                  // Individual Run for non-tx-control statements inside block
-                  if (!isTxEnd && !txPattern.test(stmt)) {
-                    addLens(stmtStartLine, stmt);
-                  }
-                  if (isTxEnd) {
-                    // Complete block — add Run Transaction at BEGIN line
-                    addLens(txBlockStartLine, txBlockStmts.join("\n"), "\u25B7 Run Transaction");
-                    txBlockStartLine = -1;
-                    txBlockStmts = [];
-                  }
-                } else {
-                  addLens(stmtStartLine, stmt);
-                }
+            // Transaction block tracking: group BEGIN...COMMIT into single Run Transaction
+            const txPattern = /^(BEGIN|COMMIT|ROLLBACK|END)(;|\s|$)/i;
+            let txBlockStartLine = -1;
+            let txBlockStmts: string[] = [];
 
-                stmtStartLine = -1;
-                stmtLines = [];
+            for (const { sql, startLine } of splitSqlStatements(model.getValue())) {
+              const isTxStart = /^BEGIN(;|\s|$)/i.test(sql);
+              const isTxEnd = /^(COMMIT|ROLLBACK|END)(;|\s|$)/i.test(sql);
+
+              if (txBlockStartLine === -1 && isTxStart) {
+                // Start collecting transaction block
+                txBlockStartLine = startLine;
+                txBlockStmts = [sql];
+              } else if (txBlockStartLine > -1) {
+                txBlockStmts.push(sql);
+                // Individual Run for non-tx-control statements inside block
+                if (!isTxEnd && !txPattern.test(sql)) {
+                  addLens(startLine, sql);
+                }
+                if (isTxEnd) {
+                  // Complete block — add Run Transaction at BEGIN line
+                  addLens(txBlockStartLine, txBlockStmts.join("\n"), "\u25B7 Run Transaction");
+                  txBlockStartLine = -1;
+                  txBlockStmts = [];
+                }
+              } else {
+                addLens(startLine, sql);
               }
             }
             // Unclosed transaction block — still offer Run Transaction
             if (txBlockStartLine > -1 && txBlockStmts.length > 1) {
               addLens(txBlockStartLine, txBlockStmts.join("\n"), "\u25B7 Run Transaction");
             }
-            if (stmtStartLine > 0 && stmtLines.join("").trim()) {
-              addLens(stmtStartLine, stmtLines.join("\n"));
-            }
             return { lenses, dispose: () => {} };
           },
         });
@@ -878,7 +852,7 @@ function SqlResultPanel({ result, error, loading, connName, onClose, onOpenInTab
           <GlideDataGrid
             columns={tableData.columns} rows={tableData.rows} total={tableData.total} limit={tableData.limit}
             schema={querySchema} loading={false}
-            page={1} onPageChange={NOOP} onCellUpdate={NOOP}
+            page={1} onPageChange={NOOP} onCellUpdate={NOOP} readOnly
             orderBy={null} orderDir="ASC" onToggleSort={NOOP}
             connectionName={connName}
           />

package/src/web/components/floating-window/window-content-registry.ts

@@ -23,6 +23,7 @@ export const WINDOW_CONTENT: Record<WindowKind, LazyExoticComponent<ComponentTyp
   "system-monitor": lazy(() => import("@/components/system/system-monitor-window-content")),
   "tab-host": lazy(() => import("./tab-host-window-content")),
   "remote-desktop": lazy(() => import("@/components/remote-desktop/remote-desktop-window-content")),
+  settings: lazy(() => import("@/components/settings/settings-window-content")),
 };
 
 /** Titlebar text for a window. Falls back to the kind's generic name. */
@@ -35,6 +36,7 @@ export function windowTitle(kind: WindowKind, payload?: Record<string, unknown>)
   }
   if (kind === "system-monitor") return "System Monitor";
   if (kind === "remote-desktop") return "Remote Desktop";
+  if (kind === "settings") return "Settings";
   // A detached tab carries its title in the payload; the generic name only shows for a
   // window whose tab has not been resolved yet (restore before the layout is loaded).
   if (kind === "tab-host") return "Tab";