quilltap 4.10.0-dev.58 → 4.10.0-dev.61

package/lib/db-commands.js

@@ -16,6 +16,7 @@ const {
   resolveProject,
 } = require('./db-helpers');
 const { getLockStatus } = require('./lock-helpers');
+const { decodeText } = require('./text-codec');
 
 // Tables grouped by domain for `db schema` (with-no-arg) overview, and for
 // DB-routing when a verb names a specific table. Keep this list short — it's
@@ -477,6 +478,11 @@ function cmdMessages(args, ctx) {
     params.push(last);
     const rows = db.prepare(sql).all(...params).reverse(); // oldest first
 
+    // `content` may be a brotli BLOB (see lib/text-codec.js). Decode before
+    // anything prints or JSON-serializes it — a raw BLOB prints as binary and
+    // JSON.stringify turns it into a byte array.
+    for (const r of rows) r.content = decodeText(r.content);
+
     if (json) return printJson({ chat, total: totalRow.n, returned: rows.length, messages: rows });
 
     console.log(`Chat: ${chat.title} (${chat.id}) — showing ${rows.length} of ${totalRow.n} matching messages`);
@@ -557,6 +563,13 @@ function cmdMessage(args, ctx) {
   try {
     const row = db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(id);
     if (!row) throw new Error(`No chat_message with id ${id}`);
+
+    // The four large text columns may be brotli BLOBs (see lib/text-codec.js).
+    // Decode before anything prints or JSON-serializes them.
+    for (const col of ['content', 'opaqueContent', 'description', 'context']) {
+      if (col in row) row[col] = decodeText(row[col]);
+    }
+
     if (json) return printJson(row);
 
     printRecord(`Message ${row.id}`, {
@@ -596,6 +609,13 @@ function cmdLog(args, ctx) {
   try {
     const row = db.prepare('SELECT * FROM llm_logs WHERE id = ?').get(id);
     if (!row) throw new Error(`No llm_log with id ${id}`);
+
+    // request/response may be brotli BLOBs (see lib/text-codec.js). Decode
+    // before anything reads, prints or JSON-serializes them — a raw BLOB
+    // would print as binary and JSON.stringify as a byte array.
+    row.request = decodeText(row.request);
+    row.response = decodeText(row.response);
+
     if (json) return printJson(row);
 
     let finishReason = null;

package/lib/db-helpers.js

@@ -2,6 +2,7 @@
 
 const path = require('path');
 const fs = require('fs');
+const { registerTextCodecFunction } = require('./text-codec');
 
 const CTRL_C = String.fromCharCode(3);
 const CTRL_D = String.fromCharCode(4);
@@ -201,6 +202,17 @@ function openEncryptedDb(dbPath, pepper, { readonly = true, friendlyName = 'data
       'The database may be encrypted with a different key, or the .dbkey file may be missing.');
   }
 
+  // Compressed text columns (llm_logs.request/response, chat_messages.content
+  // and friends) are BLOBs; qt_text() lets raw SQL and the repl read inside
+  // them. It is also REQUIRED for any --write that touches chat_messages: the
+  // message search triggers call it, so a connection without it fails the
+  // write loudly rather than letting the index drift.
+  try {
+    registerTextCodecFunction(db);
+  } catch {
+    // An old better-sqlite3 without db.function must not block a read.
+  }
+
   return db;
 }
 

package/lib/text-codec.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * Text BLOB codec — the CLI's reader for compressed text columns.
+ *
+ * MIRROR OF `lib/database/text-compression.ts` in the server repo. The CLI is
+ * published independently and cannot import from the app, so the format is
+ * duplicated here deliberately. **If the header or codec changes there, change
+ * it here in the same commit** — a stale copy shows the user mojibake.
+ *
+ * Format (see the server module for the reasoning):
+ *   [0] magic 0x51 ('Q')  [1] version 0x01  [2] codec 0x01 (brotli)  [3..] payload
+ *
+ * Values under 512 bytes are stored as plain TEXT, so a column holds a mix of
+ * compressed BLOBs and plain strings. `decodeText` accepts both, plus NULL and
+ * uncompressed buffers, and never throws.
+ */
+
+const zlib = require('zlib');
+
+const TEXT_BLOB_MAGIC = 0x51;
+const TEXT_BLOB_VERSION = 0x01;
+const TEXT_CODEC_BROTLI = 0x01;
+const TEXT_BLOB_HEADER_BYTES = 3;
+
+/** Does this value carry the compressed-text header? */
+function isCompressedTextBlob(value) {
+  if (!Buffer.isBuffer(value) || value.length < TEXT_BLOB_HEADER_BYTES) return false;
+  return (
+    value[0] === TEXT_BLOB_MAGIC &&
+    value[1] === TEXT_BLOB_VERSION &&
+    value[2] === TEXT_CODEC_BROTLI
+  );
+}
+
+/** Decode a stored value to text. Total: never throws, never returns undefined. */
+function decodeText(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return value;
+  if (!Buffer.isBuffer(value)) return String(value);
+  if (!isCompressedTextBlob(value)) return value.toString('utf-8');
+
+  const payload = value.subarray(TEXT_BLOB_HEADER_BYTES);
+  try {
+    return zlib.brotliDecompressSync(payload).toString('utf-8');
+  } catch {
+    return payload.toString('utf-8');
+  }
+}
+
+/**
+ * Register `qt_text()` on a connection, so raw SQL (`quilltap db "SELECT …"`,
+ * `--repl`) can read inside a compressed column:
+ *
+ *   SELECT json_extract(qt_text(response), '$.error') FROM llm_logs;
+ */
+function registerTextCodecFunction(db) {
+  db.function('qt_text', { deterministic: true }, (value) => decodeText(value));
+}
+
+module.exports = { decodeText, isCompressedTextBlob, registerTextCodecFunction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quilltap",
-  "version": "4.10.0-dev.58",
+  "version": "4.10.0-dev.61",
   "description": "Self-hosted AI workspace for writers, worldbuilders, and roleplayers. Run with npx quilltap.",
   "author": {
     "name": "Charles Sebold",