resplite 1.1.6 → 1.1.10

package/README.md

@@ -329,7 +329,7 @@ RESPLite implements **47 core Redis commands** (~19% of the ~246 commands in Red
 | **Lists** | LPUSH, RPUSH, LLEN, LRANGE, LINDEX, LPOP, RPOP, BLPOP, BRPOP |
 | **Sorted sets** | ZADD, ZREM, ZCARD, ZSCORE, ZRANGE, ZRANGEBYSCORE |
 | **Search (FT.\*)** | FT.CREATE, FT.INFO, FT.ADD, FT.DEL, FT.SEARCH, FT.SUGADD, FT.SUGGET, FT.SUGDEL |
-| **Introspection** | TYPE, SCAN |
+| **Introspection** | TYPE, SCAN, KEYS, MONITOR |
 | **Admin** | SQLITE.INFO, CACHE.INFO, MEMORY.INFO |
 | **Tooling** | Redis import CLI (see Migration from Redis) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resplite",
-  "version": "1.1.6",
+  "version": "1.1.10",
   "description": "A RESP2 server with practical Redis compatibility, backed by SQLite",
   "type": "module",
   "main": "src/index.js",

package/spec/SPEC_D.md

@@ -160,7 +160,7 @@ Exact fields may evolve, but these should exist.
 
 ## D.5.3 Errors
 
-* Missing index: `-ERR unknown index`
+* Missing index: `-Unknown index name`
 
 ---
 
@@ -212,7 +212,7 @@ RESP reply: `+OK`
 
 ## D.6.6 Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 * Wrong syntax: `-ERR syntax error`
 * Missing `FIELDS`: `-ERR syntax error`
 * Unknown field: `-ERR unknown field`
@@ -248,7 +248,7 @@ RESP Integer:
 
 ## D.7.4 Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 
 ---
 
@@ -346,7 +346,7 @@ Compute total efficiently:
 
 ## D.8.8 Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 * Bad syntax: `-ERR syntax error`
 * Invalid LIMIT: `-ERR invalid limit`
 * Unsafe query: `-ERR invalid query`
@@ -383,7 +383,7 @@ RESP Integer:
 
 ### Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 * Score invalid: `-ERR invalid score`
 
 ## D.9.2 FT.SUGGET
@@ -425,7 +425,7 @@ Not supported (v1):
 
 ### Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 * Bad syntax: `-ERR syntax error`
 
 ## D.9.3 FT.SUGDEL
@@ -449,7 +449,7 @@ RESP Integer:
 
 ### Errors
 
-* Index missing: `-ERR unknown index`
+* Index missing: `-Unknown index name`
 
 ---
 

package/src/commands/ft-add.js

@@ -20,6 +20,6 @@ export function handleFtAdd(engine, args) {
     return { simple: 'OK' };
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-create.js

@@ -15,6 +15,6 @@ export function handleFtCreate(engine, args) {
     return { simple: 'OK' };
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-del.js

@@ -15,6 +15,6 @@ export function handleFtDel(engine, args) {
     return n;
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-info.js

@@ -32,6 +32,6 @@ export function handleFtInfo(engine, args) {
     ];
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-search.js

@@ -33,6 +33,6 @@ export function handleFtSearch(engine, args) {
     return out;
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-sugadd.js

@@ -22,6 +22,6 @@ export function handleFtSugadd(engine, args) {
     return n;
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-sugdel.js

@@ -15,6 +15,6 @@ export function handleFtSugdel(engine, args) {
     return n;
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/ft-sugget.js

@@ -19,6 +19,6 @@ export function handleFtSugget(engine, args) {
     return list;
   } catch (e) {
     const msg = e?.message ?? String(e);
-    return { error: msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
+    return { error: msg === 'Unknown index name' ? msg : msg.startsWith('ERR ') ? msg : 'ERR ' + msg };
   }
 }

package/src/commands/keys.js

@@ -0,0 +1,67 @@
+/**
+ * KEYS pattern - return all keys matching the glob pattern.
+ */
+
+function escapeRegexChar(ch) {
+  return /[\\^$+?.()|{}]/.test(ch) ? '\\' + ch : ch;
+}
+
+function globToRegExp(glob) {
+  let out = '^';
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob[i];
+    if (ch === '\\') {
+      if (i + 1 < glob.length) {
+        out += escapeRegexChar(glob[i + 1]);
+        i += 2;
+      } else {
+        out += '\\\\';
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === '*') {
+      out += '.*';
+      i += 1;
+      continue;
+    }
+    if (ch === '?') {
+      out += '.';
+      i += 1;
+      continue;
+    }
+    out += escapeRegexChar(ch);
+    i += 1;
+  }
+  out += '$';
+  return new RegExp(out);
+}
+
+export function handleKeys(engine, args) {
+  if (!args || args.length !== 1) {
+    return { error: 'ERR wrong number of arguments for \'KEYS\' command' };
+  }
+  const pattern = args[0].toString('utf8');
+  const matcher = globToRegExp(pattern);
+  const seen = new Set();
+  const matches = [];
+
+  let cursor = '0';
+  do {
+    const scanned = engine.scan(cursor, { count: 256 });
+    const keys = scanned.keys ?? [];
+    for (const key of keys) {
+      if (!Buffer.isBuffer(key)) continue;
+      const hex = key.toString('hex');
+      if (seen.has(hex)) continue;
+      seen.add(hex);
+      if (engine.type(key) === 'none') continue;
+      const keyText = key.toString('utf8');
+      if (matcher.test(keyText)) matches.push(key);
+    }
+    cursor = String(scanned.cursor);
+  } while (cursor !== '0');
+
+  return matches;
+}

package/src/commands/monitor.js

@@ -0,0 +1,10 @@
+/**
+ * MONITOR - switch the current connection to monitor mode.
+ */
+
+export function handleMonitor(args) {
+  if (args && args.length !== 0) {
+    return { error: 'ERR wrong number of arguments for \'MONITOR\' command' };
+  }
+  return { simple: 'OK' };
+}

package/src/commands/registry.js

@@ -46,6 +46,7 @@ import * as lrem from './lrem.js';
 import * as blpop from './blpop.js';
 import * as brpop from './brpop.js';
 import * as scan from './scan.js';
+import * as keys from './keys.js';
 import * as zadd from './zadd.js';
 import * as zrem from './zrem.js';
 import * as zcard from './zcard.js';
@@ -63,6 +64,7 @@ import * as ftSearch from './ft-search.js';
 import * as ftSugadd from './ft-sugadd.js';
 import * as ftSugget from './ft-sugget.js';
 import * as ftSugdel from './ft-sugdel.js';
+import * as monitor from './monitor.js';
 
 const HANDLERS = new Map([
   ['PING', (e, a) => ping.handlePing()],
@@ -108,6 +110,7 @@ const HANDLERS = new Map([
   ['BLPOP', (e, a, ctx) => blpop.handleBlpop(e, a, ctx)],
   ['BRPOP', (e, a, ctx) => brpop.handleBrpop(e, a, ctx)],
   ['SCAN', (e, a) => scan.handleScan(e, a)],
+  ['KEYS', (e, a) => keys.handleKeys(e, a)],
   ['ZADD', (e, a) => zadd.handleZadd(e, a)],
   ['ZREM', (e, a) => zrem.handleZrem(e, a)],
   ['ZCARD', (e, a) => zcard.handleZcard(e, a)],
@@ -125,6 +128,7 @@ const HANDLERS = new Map([
   ['FT.SUGADD', (e, a) => ftSugadd.handleFtSugadd(e, a)],
   ['FT.SUGGET', (e, a) => ftSugget.handleFtSugget(e, a)],
   ['FT.SUGDEL', (e, a) => ftSugdel.handleFtSugdel(e, a)],
+  ['MONITOR', (e, a, ctx) => monitor.handleMonitor(a, ctx)],
 ]);
 
 /**

package/src/server/connection.js

@@ -5,6 +5,7 @@
 import { RESPReader } from '../resp/parser.js';
 import { dispatch } from '../commands/registry.js';
 import { encode, encodeSimpleString, encodeError } from '../resp/encoder.js';
+import { registerMonitorClient, unregisterMonitorClient, broadcastMonitorCommand } from './monitor.js';
 
 let nextConnectionId = 0;
 
@@ -17,6 +18,8 @@ export function handleConnection(socket, engine) {
   const connectionId = ++nextConnectionId;
   const context = {
     connectionId,
+    monitorMode: false,
+    clientAddress: `${socket.remoteAddress ?? 'unknown'}:${socket.remotePort ?? 0}`,
     writeResponse(buf) {
       if (socket.writable) socket.write(buf);
     },
@@ -46,7 +49,18 @@ export function handleConnection(socket, engine) {
     reader.feed(chunk);
     const commands = reader.parseCommands();
     for (const argv of commands) {
+      const cmd = argv[0] ? argv[0].toString('utf8').toUpperCase() : '';
+      if (context.monitorMode && cmd !== 'QUIT') {
+        socket.write(encodeError('ERR MONITOR mode only supports QUIT'));
+        continue;
+      }
       const out = dispatch(engine, argv, context);
+      if (cmd === 'MONITOR' && !out.error) {
+        context.monitorMode = true;
+        registerMonitorClient(context);
+      } else if (!context.monitorMode) {
+        broadcastMonitorCommand(argv, context);
+      }
       if (out.quit) {
         writeResult(out);
         return;
@@ -77,6 +91,7 @@ export function handleConnection(socket, engine) {
 
   socket.on('close', () => {
     if (engine._blockingManager) engine._blockingManager.cancel(connectionId);
+    unregisterMonitorClient(connectionId);
   });
 
   socket.on('error', () => {});

package/src/server/monitor.js

@@ -0,0 +1,59 @@
+/**
+ * MONITOR support: track monitor clients and broadcast command traces.
+ */
+
+import { encodeSimpleString } from '../resp/encoder.js';
+
+const monitorClients = new Map();
+
+function escapeArg(value) {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t');
+}
+
+function formatCommand(argv) {
+  const parts = [];
+  for (const arg of argv) {
+    const text = Buffer.isBuffer(arg) ? arg.toString('utf8') : String(arg);
+    parts.push('"' + escapeArg(text) + '"');
+  }
+  return parts.join(' ');
+}
+
+function timestamp() {
+  const now = Date.now();
+  const sec = Math.floor(now / 1000);
+  const micros = String((now % 1000) * 1000).padStart(6, '0');
+  return sec + '.' + micros;
+}
+
+function sourceLabel(sourceContext) {
+  const label = sourceContext && sourceContext.clientAddress ? sourceContext.clientAddress : 'unknown';
+  return '[0 ' + label + ']';
+}
+
+export function registerMonitorClient(context) {
+  if (!context || !context.connectionId) return;
+  monitorClients.set(context.connectionId, context);
+}
+
+export function unregisterMonitorClient(connectionId) {
+  if (!connectionId) return;
+  monitorClients.delete(connectionId);
+}
+
+export function broadcastMonitorCommand(argv, sourceContext) {
+  if (!Array.isArray(argv) || argv.length === 0) return;
+  if (monitorClients.size === 0) return;
+  const line = timestamp() + ' ' + sourceLabel(sourceContext) + ' ' + formatCommand(argv);
+  const payload = encodeSimpleString(line);
+  for (const monitor of monitorClients.values()) {
+    if (monitor && typeof monitor.writeResponse === 'function') {
+      monitor.writeResponse(payload);
+    }
+  }
+}

package/src/storage/sqlite/search.js

@@ -116,7 +116,7 @@ export function getIndexMeta(db, name) {
   const row = db.prepare(
     'SELECT name, schema_json, created_at, updated_at FROM search_indices WHERE name = ?'
   ).get(name);
-  if (!row) throw new Error('ERR unknown index');
+  if (!row) throw new Error('Unknown index name');
   const schema = JSON.parse(row.schema_json);
   return {
     name: row.name,

package/test/integration/keys.test.js

@@ -0,0 +1,49 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+describe('KEYS integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('KEYS * returns matching keys', async () => {
+    await sendCommand(port, argv('SET', 'keys:k1', 'v1'));
+    await sendCommand(port, argv('SET', 'keys:k2', 'v2'));
+    await sendCommand(port, argv('SET', 'other:k3', 'v3'));
+
+    const reply = await sendCommand(port, argv('KEYS', 'keys:*'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(Array.isArray(parsed.value));
+    const values = parsed.value.map((v) => v.toString('utf8')).sort();
+    assert.deepEqual(values, ['keys:k1', 'keys:k2']);
+  });
+
+  it('KEYS with ? wildcard works', async () => {
+    await sendCommand(port, argv('SET', 'q:a1', 'x'));
+    await sendCommand(port, argv('SET', 'q:b2', 'x'));
+    await sendCommand(port, argv('SET', 'q:bb2', 'x'));
+
+    const reply = await sendCommand(port, argv('KEYS', 'q:?2'));
+    const parsed = tryParseValue(reply, 0);
+    const values = parsed.value.map((v) => v.toString('utf8')).sort();
+    assert.deepEqual(values, ['q:b2']);
+  });
+
+  it('KEYS wrong number of arguments returns error', async () => {
+    const reply = await sendCommand(port, argv('KEYS'));
+    const parsed = tryParseValue(reply, 0);
+    assert.ok(parsed.value && parsed.value.error);
+    assert.ok(parsed.value.error.includes('wrong number of arguments'));
+  });
+});

package/test/integration/monitor.test.js

@@ -0,0 +1,102 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { createTestServer } from '../helpers/server.js';
+import { sendCommand, argv } from '../helpers/client.js';
+import { encode } from '../../src/resp/encoder.js';
+import { tryParseValue } from '../../src/resp/parser.js';
+
+function createStreamingClient(port) {
+  return new Promise((resolve, reject) => {
+    let recv = Buffer.alloc(0);
+    const queue = [];
+    const waiters = [];
+    const socket = net.createConnection({ port, host: '127.0.0.1' }, () => {
+      resolve({
+        send(commandArgv) {
+          socket.write(encode(commandArgv));
+        },
+        async nextValue(timeoutMs = 2000) {
+          if (queue.length > 0) return queue.shift();
+          return new Promise((res, rej) => {
+            const timer = setTimeout(() => {
+              const idx = waiters.findIndex((w) => w.resolve === res);
+              if (idx >= 0) waiters.splice(idx, 1);
+              rej(new Error('timeout waiting for RESP value'));
+            }, timeoutMs);
+            waiters.push({
+              resolve(value) {
+                clearTimeout(timer);
+                res(value);
+              },
+            });
+          });
+        },
+        close() {
+          socket.destroy();
+        },
+      });
+    });
+
+    socket.on('data', (chunk) => {
+      recv = Buffer.concat([recv, chunk]);
+      for (;;) {
+        const parsed = tryParseValue(recv, 0);
+        if (parsed === null) break;
+        recv = recv.subarray(parsed.end);
+        if (waiters.length > 0) {
+          waiters.shift().resolve(parsed.value);
+        } else {
+          queue.push(parsed.value);
+        }
+      }
+    });
+    socket.on('error', reject);
+  });
+}
+
+describe('MONITOR integration', () => {
+  let s;
+  let port;
+
+  before(async () => {
+    s = await createTestServer();
+    port = s.port;
+  });
+
+  after(async () => {
+    await s.closeAsync();
+  });
+
+  it('MONITOR streams commands from other clients', async () => {
+    const monitorClient = await createStreamingClient(port);
+    try {
+      monitorClient.send(argv('MONITOR'));
+      const first = await monitorClient.nextValue();
+      assert.equal(first, 'OK');
+
+      await sendCommand(port, argv('SET', 'mk1', 'v1'));
+      const event = await monitorClient.nextValue();
+      assert.equal(typeof event, 'string');
+      assert.match(event, /"SET"\s+"mk1"\s+"v1"/);
+    } finally {
+      monitorClient.close();
+    }
+  });
+
+  it('MONITOR connection only accepts QUIT', async () => {
+    const monitorClient = await createStreamingClient(port);
+    try {
+      monitorClient.send(argv('MONITOR'));
+      assert.equal(await monitorClient.nextValue(), 'OK');
+      monitorClient.send(argv('PING'));
+      const err = await monitorClient.nextValue();
+      assert.ok(err && err.error);
+      assert.match(err.error, /MONITOR mode only supports QUIT/);
+      monitorClient.send(argv('QUIT'));
+      assert.equal(await monitorClient.nextValue(), 'OK');
+    } finally {
+      monitorClient.close();
+    }
+  });
+});

package/test/integration/search.test.js

@@ -117,7 +117,7 @@ describe('Search integration', () => {
     const reply = await sendCommand(port, argv('FT.INFO', 'nonexistent'));
     const v = tryParseValue(reply, 0).value;
     const err = v?.error ?? v;
-    assert.ok(String(err).includes('unknown index'));
+    assert.ok(String(err).includes('Unknown index name'));
   });
 });
 

package/test/unit/search.test.js

@@ -135,6 +135,6 @@ describe('Search layer', () => {
   });
 
   it('getIndexMeta throws for unknown index', () => {
-    assert.throws(() => getIndexMeta(db, 'nonexistent'), /unknown index/);
+    assert.throws(() => getIndexMeta(db, 'nonexistent'), /Unknown index name/);
   });
 });

package/tasks/todo.md

@@ -1,44 +0,0 @@
-# Migration from Redis (SPEC §26)
-
-## Plan
-
-- [x] Review SPEC §26 (Migration Strategy) and §10 (Data model)
-- [x] Implement external CLI tool (not part of RESP server)
-- [x] Method: connect to Redis → SCAN → TYPE → fetch by type (GET / HGETALL / SMEMBERS) → PTTL → write to SQLite
-- [x] Migratable subset: strings, hashes, sets, TTL metadata
-- [x] Skip unsupported types (list, zset, stream, etc.) with report
-- [x] Contract test using local Redis (skip if Redis unavailable)
-
-## Implementation
-
-- **CLI**: `src/cli/import-from-redis.js` — `node src/cli/import-from-redis.js --redis-url redis://127.0.0.1:6379 --db ./migrated.db`
-- **Storage**: Reuse existing `openDb`, `createKeysStorage`, `createStringsStorage`, `createHashesStorage`, `createSetsStorage`; write via storage layer with Buffer values
-- **Binary safety**: Redis client returns strings; coerce to Buffer (utf8) when writing to SQLite
-
-## Verification
-
-- Run contract test: `npm run test:contract` (includes import-from-redis test when Redis is available)
-- Manual: populate local Redis, run CLI, start RESPlite with migrated db, verify keys/values/TTL
-
-## Not in scope (SPEC §26.3)
-
-- RDB parsing, AOF parsing, mirror mode, dual-write
-
----
-
-# Migration with Dirty Key Registry (SPEC_F)
-
-## Done
-
-- [x] Migration schema: `migration_runs`, `migration_dirty_keys`, `migration_errors` in `src/storage/sqlite/migration-schema.js`
-- [x] Registry layer: `src/migration/registry.js` (createRun, getRun, updateBulkProgress, upsertDirtyKey, getDirtyBatch, markDirtyState, logError, getDirtyCounts)
-- [x] Bulk importer: `src/migration/bulk.js` with run_id, checkpointing, resume, max_rps, batch_keys/batch_bytes, pause/abort via status
-- [x] Shared import-one: `src/migration/import-one.js` (fetch key from Redis + write to storages; used by bulk and apply-dirty)
-- [x] Delta apply: `src/migration/apply-dirty.js` (apply dirty keys from registry: reimport or delete in destination)
-- [x] Preflight: `src/migration/preflight.js` (key count, type distribution, notify-keyspace-events check, recommendations)
-- [x] Verify: `src/migration/verify.js` (sample keys, compare Redis vs RespLite)
-- [x] CLI `resplite-import`: `src/cli/resplite-import.js` (preflight, bulk, status, apply-dirty, verify)
-- [x] CLI `resplite-dirty-tracker`: `src/cli/resplite-dirty-tracker.js` (start = PSUBSCRIBE keyevent, stop = update run status)
-- [x] package.json `bin`: resplite-import, resplite-dirty-tracker
-- [x] Unit tests: `test/unit/migration-registry.test.js`
-- [x] README: minimal-downtime migration flow and commands