@hienlh/ppm 0.19.0 → 0.19.2

package/src/web/components/chat/message-input.tsx

@@ -2,6 +2,8 @@ import { useState, useRef, useCallback, useEffect, memo, type KeyboardEvent, typ
 import { ArrowUp, Square, Paperclip, Loader2, Mic, MicOff, Zap, ListOrdered, Clock, Bot, X } from "lucide-react";
 import { useVoiceInput } from "@/hooks/use-voice-input";
 import { api, projectUrl, getAuthToken } from "@/lib/api-client";
+import { downscaleImage } from "@/lib/image-resize";
+import { INLINE_IMAGE_LIMITS } from "@/lib/image-resize-limits";
 import { randomId } from "@/lib/utils";
 import { ownsGlobalShortcut } from "@/lib/owns-global-shortcut";
 import { SEND_TO_CHAT_EVENT, SEND_TO_CHAT_ACK_EVENT, type SendToChatDetail } from "@/lib/send-to-chat";
@@ -17,6 +19,29 @@ import { fetchSlashItems, clearSlashItemsCache } from "@/lib/slash-items-cache";
 import type { FileNode } from "../../../types/project";
 import { useFileStore } from "@/stores/file-store";
 
+/**
+ * Base64 payload for an image file, or undefined when it cannot be read.
+ *
+ * Reads through FileReader rather than assembling the string by hand: a phone photo is
+ * millions of characters, and building it in chunks on the main thread freezes the composer
+ * for as long as it takes.
+ */
+async function readImageData(file: File): Promise<{ data: string; mediaType: string } | undefined> {
+  try {
+    const dataUrl = await new Promise<string>((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(String(reader.result ?? ""));
+      reader.onerror = () => reject(reader.error);
+      reader.readAsDataURL(file);
+    });
+    const comma = dataUrl.indexOf(",");
+    const data = comma >= 0 ? dataUrl.slice(comma + 1) : "";
+    return data ? { data, mediaType: file.type || "image/png" } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export interface ChatAttachment {
   id: string;
   name: string;
@@ -27,6 +52,16 @@ export interface ChatAttachment {
   serverPath?: string;
   /** Inline text content (e.g. terminal output) — no upload needed */
   textContent?: string;
+  /**
+   * Base64 payload for an image, sent as part of the message itself.
+   *
+   * Passing the path instead would make the model spend a whole extra round trip calling Read
+   * to fetch it, and every round trip re-sends the entire transcript. The uploaded copy is
+   * still kept, so removing the payload from a transcript later stays recoverable.
+   */
+  imageData?: { data: string; mediaType: string };
+  /** Dimensions before and after downscaling, when one happened — surfaced in the chip. */
+  resized?: { from: { width: number; height: number }; to: { width: number; height: number } };
   status: "uploading" | "ready" | "error";
 }
 
@@ -436,6 +471,27 @@ export const MessageInput = memo(function MessageInput({
     onExternalPathsConsumed?.();
   }, [externalPaths]); // eslint-disable-line react-hooks/exhaustive-deps
 
+  /** Delete an upload the user removed before sending. Best effort — nothing depends on it. */
+  const discardUpload = useCallback(
+    async (serverPath: string) => {
+      if (!projectName) return;
+      const filename = serverPath.split(/[\\/]/).pop();
+      if (!filename) return;
+      try {
+        const headers: HeadersInit = {};
+        const token = getAuthToken();
+        if (token) headers["Authorization"] = `Bearer ${token}`;
+        await fetch(`${projectUrl(projectName)}/chat/uploads/${encodeURIComponent(filename)}`, {
+          method: "DELETE",
+          headers,
+        });
+      } catch {
+        // An orphaned file is not worth surfacing to the user.
+      }
+    },
+    [projectName],
+  );
+
   /** Upload a single file to the server, return server path */
   const uploadFile = useCallback(
     async (file: File): Promise<string | null> => {
@@ -466,32 +522,64 @@ export const MessageInput = memo(function MessageInput({
   /** Process files — always uploads to server. Path resolution only happens via @ picker. */
   const processFiles = useCallback(
     async (files: File[]) => {
-      for (const file of files) {
+      for (const original of files) {
         const id = randomId();
-        const isImg = isImageFile(file);
-        const previewUrl = isImg ? URL.createObjectURL(file) : undefined;
+        const isImg = isImageFile(original);
 
         const att: ChatAttachment = {
           id,
-          name: file.name,
-          file,
+          name: original.name,
+          file: original,
           isImage: isImg,
-          previewUrl,
+          previewUrl: isImg ? URL.createObjectURL(original) : undefined,
           status: "uploading",
         };
 
         setAttachments((prev) => [...prev, att]);
 
-        // Upload in background
-        uploadFile(file).then((serverPath) => {
+        // Shrink first, so the upload, the preview and the message all carry the same
+        // already-reduced image — an oversized original must not reach the transcript.
+        //
+        // Only a `scaled` or `inlineable` result is attached inline. An image that could not
+        // be measured or re-encoded travels by path alone: sending unverified dimensions
+        // inline risks a payload the API refuses, and that refusal outlives the turn, since
+        // the transcript replays it into every later one.
+        try {
+          const outcome = isImg ? await downscaleImage(original) : null;
+          const file = outcome?.file ?? original;
+          // Point the thumbnail at the reduced file and let the original go. It is the larger
+          // of the two and nothing needs it once the resize is done, but it stayed alive until
+          // the message was sent because the preview still referenced it.
+          const previewUrl = isImg && file !== original ? URL.createObjectURL(file) : undefined;
+          const serverPath = await uploadFile(file);
+          const inlineable = outcome ? outcome.kind !== "asis" : false;
+          const imageData = inlineable ? await readImageData(file) : undefined;
+          const withinPayloadCap =
+            !!imageData && imageData.data.length <= INLINE_IMAGE_LIMITS.maxBase64PerImage;
+
+          if (previewUrl && att.previewUrl) URL.revokeObjectURL(att.previewUrl);
           setAttachments((prev) =>
             prev.map((a) =>
               a.id === id
-                ? { ...a, serverPath: serverPath ?? undefined, status: serverPath ? "ready" : "error" }
+                ? {
+                    ...a,
+                    file,
+                    ...(previewUrl && { previewUrl }),
+                    serverPath: serverPath ?? undefined,
+                    imageData: withinPayloadCap ? imageData : undefined,
+                    resized: outcome?.to ? { from: outcome.from!, to: outcome.to } : undefined,
+                    // An image can still be sent inline when the upload failed; anything
+                    // else has nothing left to send without its path.
+                    status: serverPath || withinPayloadCap ? "ready" : "error",
+                  }
                 : a,
             ),
           );
-        });
+        } catch {
+          // Nothing here may leave an attachment stuck on "uploading" — both the send button
+          // and the auto-send effect wait on that state, so a swallowed throw hangs the composer.
+          setAttachments((prev) => prev.map((a) => (a.id === id ? { ...a, status: "error" } : a)));
+        }
       }
       (mobileTextareaRef.current ?? textareaRef.current)?.focus();
     },
@@ -502,9 +590,12 @@ export const MessageInput = memo(function MessageInput({
     setAttachments((prev) => {
       const att = prev.find((a) => a.id === id);
       if (att?.previewUrl) URL.revokeObjectURL(att.previewUrl);
+      // Uploads are never swept, because chat history points at them indefinitely, so one
+      // abandoned before it was ever sent would sit there with nothing referencing it.
+      if (att?.serverPath) void discardUpload(att.serverPath);
       return prev.filter((a) => a.id !== id);
     });
-  }, []);
+  }, [discardUpload]);
 
   /** Execute the actual send (called directly or after uploads complete) */
   const executeSend = useCallback(() => {

package/src/web/components/chat/session-debug-dialog.tsx

@@ -147,7 +147,8 @@ function TranscriptImages({ sessionId, projectName }: { sessionId: string; proje
               {audit.oversizedAttachments} of those {audit.oversizedAttachments === 1 ? "is an image you" : "are images you"}
               {" "}attached yourself, so the buttons below leave {audit.oversizedAttachments === 1 ? "it" : "them"} in place.
               While {audit.oversizedAttachments === 1 ? "it stays" : "they stay"}, every turn in this session keeps failing.
-              The transcript holds the only copy — removing {audit.oversizedAttachments === 1 ? "it" : "them"} cannot be undone.
+              Removing {audit.oversizedAttachments === 1 ? "it" : "them"} cannot be undone: an attachment PPM sent keeps
+              a copy on disk with its path still in the message, but one from another client does not.
             </span>
           </div>
           <Button

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,
   };
 }