@hasna/mementos 0.14.85 → 0.14.86

package/dist/project-registration.js

@@ -235,6 +235,7 @@ function translateSql(sql) {
   let translated = sql.replace(/\?/g, () => `$${++parameterIndex}`);
   const ISO_FMT = `'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'`;
   translated = translated.replace(/datetime\s*\(\s*'now'\s*\)/gi, `to_char(now() AT TIME ZONE 'UTC', ${ISO_FMT})`);
+  translated = translated.replace(/strftime\s*\(\s*'%Y-%m-%dT%H:%M:%fZ'\s*,\s*'now'\s*\)/gi, `to_char(now() AT TIME ZONE 'UTC', ${ISO_FMT})`);
   translated = translated.replace(/datetime\s*\(\s*'now'\s*,\s*'(-?\d+)\s+(minutes?|hours?|days?|seconds?)'\s*\)/gi, (_match, amount, unit) => {
     const parsed = parseInt(String(amount), 10);
     const absolute = Math.abs(parsed);
@@ -736,16 +737,24 @@ function transferRows(target, table, rows, options) {
   const conflictColumn = options.conflictColumn ?? "updated_at";
   let written = 0;
   let skipped = 0;
+  let maxSyncedAt = null;
   const errors = [];
+  const bumpMaxSyncedAt = (row) => {
+    const value = row[conflictColumn];
+    if (typeof value === "string" && (maxSyncedAt === null || value > maxSyncedAt)) {
+      maxSyncedAt = value;
+    }
+  };
   if (rows.length === 0) {
-    return { written, skipped, errors };
+    return { written, skipped, errors, maxSyncedAt };
   }
   const columns = Object.keys(rows[0] ?? {});
   if (!columns.includes(primaryKey)) {
     return {
       written,
       skipped,
-      errors: [`Table "${table}" has no "${primaryKey}" column; skipping`]
+      errors: [`Table "${table}" has no "${primaryKey}" column; skipping`],
+      maxSyncedAt
     };
   }
   const hasConflictColumn = columns.includes(conflictColumn);
@@ -758,6 +767,7 @@ function transferRows(target, table, rows, options) {
           const incomingTime = Date.parse(String(row[conflictColumn]));
           if (Number.isFinite(existingTime) && Number.isFinite(incomingTime) && existingTime >= incomingTime) {
             skipped++;
+            bumpMaxSyncedAt(row);
             continue;
           }
         }
@@ -770,11 +780,12 @@ function transferRows(target, table, rows, options) {
         target.run(`INSERT INTO "${table}" (${columnList}) VALUES (${placeholders})`, ...columns.map((column) => row[column]));
       }
       written++;
+      bumpMaxSyncedAt(row);
     } catch (error) {
       errors.push(`Row ${String(row[primaryKey] ?? "unknown")}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return { written, skipped, errors };
+  return { written, skipped, errors, maxSyncedAt };
 }
 function incrementalSyncPush(local, remote, tables, options = {}) {
   return runIncrementalSync("push", local, remote, local, tables, options);
@@ -812,22 +823,29 @@ function runIncrementalSync(direction, source, target, metaDb, tables, options)
         rows = source.all(`SELECT * FROM "${table}"`);
         stat.first_sync = true;
       }
+      let maxSyncedAt = null;
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
         const result = transferRows(target, table, batch, options);
         stat.synced_rows += result.written;
         stat.skipped_rows += result.skipped;
         stat.errors.push(...result.errors);
+        if (result.maxSyncedAt !== null && (maxSyncedAt === null || result.maxSyncedAt > maxSyncedAt)) {
+          maxSyncedAt = result.maxSyncedAt;
+        }
       }
       if (rows.length === 0) {
         stat.skipped_rows = stat.total_rows;
       }
-      upsertSyncMeta(metaDb, {
-        table_name: table,
-        last_synced_at: new Date().toISOString(),
-        last_synced_row_count: stat.synced_rows,
-        direction
-      });
+      const nextCursor = maxSyncedAt ?? meta?.last_synced_at ?? null;
+      if (rows.length > 0 && stat.errors.length === 0 && nextCursor !== null) {
+        upsertSyncMeta(metaDb, {
+          table_name: table,
+          last_synced_at: nextCursor,
+          last_synced_row_count: stat.synced_rows,
+          direction
+        });
+      }
     } catch (error) {
       stat.errors.push(`Table "${table}": ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -866,8 +884,13 @@ var init_storage = __esm(() => {
     data;
     closed = false;
     lastError = null;
+    generation = 0;
     static DATA_BYTES = 128 * 1024 * 1024;
-    static QUERY_TIMEOUT_MS = 60000;
+    static queryTimeoutMs() {
+      const raw = process.env["MEMENTOS_PGSYNC_QUERY_TIMEOUT_MS"]?.trim();
+      const parsed = raw ? Number(raw) : Number.NaN;
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : 60000;
+    }
     static resolveWorkerPath() {
       const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
       const here = fileURLToPath(new URL(".", import.meta.url));
@@ -882,12 +905,12 @@ var init_storage = __esm(() => {
       }
       return candidates[0];
     }
-    constructor(connectionString) {
-      const control = new SharedArrayBuffer(8);
+    constructor(connectionString, workerPath) {
+      const control = new SharedArrayBuffer(12);
       const dataSab = new SharedArrayBuffer(PgSyncPool.DATA_BYTES);
       this.status = new Int32Array(control);
       this.data = new Uint8Array(dataSab);
-      this.worker = new Worker(PgSyncPool.resolveWorkerPath(), {
+      this.worker = new Worker(workerPath ?? PgSyncPool.resolveWorkerPath(), {
         workerData: {
           dsn: stripSslParams(connectionString),
           ssl: sslConfigFor(connectionString),
@@ -905,21 +928,35 @@ var init_storage = __esm(() => {
         throw new Error("PgSyncPool is closed");
       if (this.lastError)
         throw this.lastError;
+      const timeoutMs = PgSyncPool.queryTimeoutMs();
+      const gen = ++this.generation;
       Atomics.store(this.status, 0, 0);
-      this.worker.postMessage({ sql, params });
-      const waitResult = Atomics.wait(this.status, 0, 0, PgSyncPool.QUERY_TIMEOUT_MS);
-      const code = Atomics.load(this.status, 0);
-      if (code === 0 || waitResult === "timed-out") {
-        if (this.lastError)
-          throw this.lastError;
-        throw new Error("PostgreSQL query timed out after 60s");
-      }
-      const len = Atomics.load(this.status, 1);
-      const payload = JSON.parse(new TextDecoder().decode(this.data.subarray(0, len)));
-      if (code === 2) {
-        throw new Error(payload.message ?? "PostgreSQL error");
+      Atomics.store(this.status, 2, 0);
+      this.worker.postMessage({ sql, params, gen });
+      const deadline = Date.now() + timeoutMs;
+      for (;; ) {
+        const remaining = deadline - Date.now();
+        const responding = Atomics.load(this.status, 0);
+        if (responding === gen) {
+          const code = Atomics.load(this.status, 2);
+          const len = Atomics.load(this.status, 1);
+          const payload = JSON.parse(new TextDecoder().decode(this.data.subarray(0, len)));
+          if (code === 2) {
+            throw new Error(payload.message ?? "PostgreSQL error");
+          }
+          return payload;
+        }
+        if (responding !== 0) {
+          Atomics.compareExchange(this.status, 0, responding, 0);
+          continue;
+        }
+        if (remaining <= 0) {
+          if (this.lastError)
+            throw this.lastError;
+          throw new Error(`PostgreSQL query timed out after ${timeoutMs}ms`);
+        }
+        Atomics.wait(this.status, 0, 0, remaining);
       }
-      return payload;
     }
     end() {
       if (this.closed)
@@ -5355,7 +5392,26 @@ function parseMemoryRow(row) {
     accessed_at: row["accessed_at"] || null
   };
 }
+var RESERVED_AGENT_IDS = new Set([
+  "agent-a",
+  "agent-x",
+  "agent-z",
+  "nonexistent-agent"
+]);
+function reservedAgentIdViolation(agentId) {
+  if (!agentId)
+    return null;
+  const normalized = agentId.trim().toLowerCase();
+  if (RESERVED_AGENT_IDS.has(normalized)) {
+    return `Reserved placeholder agent id "${agentId}" cannot own a memory. ` + `Refusing to write: test harnesses must not write memories under placeholder agent ` + `identities. Register a real agent (mementos register-agent <name>) and pass its id.`;
+  }
+  return null;
+}
 function createMemory(input, dedupeMode = "merge", db) {
+  const reservedViolation = reservedAgentIdViolation(input.agent_id);
+  if (reservedViolation) {
+    throw new Error(reservedViolation);
+  }
   if (!db && isApiMode()) {
     const { status, data } = apiJson("POST", "/memories", { ...input, dedupe: dedupeMode });
     if (!data || !data.id) {
@@ -5405,7 +5461,8 @@ function createMemory(input, dedupeMode = "merge", db) {
            importance = ?, metadata = ?, expires_at = ?,
            when_to_use = ?,
            pinned = COALESCE(pinned, 0),
-           version = version + 1, updated_at = ?
+           version = version + 1, updated_at = ?,
+           updated_by_agent = ?
          WHERE id = ?`, [
         safeValue,
         input.category || "knowledge",
@@ -5416,6 +5473,7 @@ function createMemory(input, dedupeMode = "merge", db) {
         expiresAt,
         input.when_to_use || null,
         timestamp,
+        input.agent_id || null,
         existing.id
       ]);
       d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
@@ -5717,6 +5775,11 @@ function listMemoriesPage(filter, db) {
       agent_id: f.agent_id,
       project_id: f.project_id,
       session_id: f.session_id,
+      machine_id: f.machine_id,
+      visible_to_machine_id: f.visible_to_machine_id,
+      search: f.search,
+      source: f.source,
+      flag: f.flag,
       namespace: f.namespace,
       as_of: f.as_of,
       limit: f.limit,
@@ -5859,20 +5922,29 @@ function updateMemory(id, input, db) {
     sets.push("when_to_use = ?");
     params.push(input.when_to_use ?? null);
   }
+  if (input.updated_by_agent !== undefined) {
+    sets.push("updated_by_agent = ?");
+    params.push(input.updated_by_agent ?? null);
+  }
   if (input.tags !== undefined) {
     sets.push("tags = ?");
     params.push(JSON.stringify(input.tags));
-    d.run("DELETE FROM memory_tags WHERE memory_id = ?", [memoryId]);
-    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
-    for (const tag of input.tags) {
-      insertTag.run(memoryId, tag);
-    }
   }
   params.push(memoryId);
-  const result = d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
-  if (result.changes === 0) {
-    throw new Error(`Update affected no rows for memory ${memoryId}: the record was read but not written. ` + `This is a bug in @hasna/mementos, not a bad argument \u2014 please report it.`);
-  }
+  d.transaction(() => {
+    const res = d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
+    if (res.changes === 0) {
+      throw new Error(`Update affected no rows for memory ${memoryId}: the record was read but not written. ` + `This is a bug in @hasna/mementos, not a bad argument \u2014 please report it.`);
+    }
+    if (input.tags !== undefined) {
+      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [memoryId]);
+      const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+      for (const tag of input.tags) {
+        insertTag.run(memoryId, tag);
+      }
+    }
+    return res;
+  });
   const updated = getMemory(memoryId, d);
   if (input.value !== undefined) {
     try {

package/dist/sdk/index.js

@@ -181,6 +181,7 @@ class MementosClient {
       const limit = Math.min(want === undefined ? pageSize : want - memories.length, pageSize);
       const page = await this.get("/api/memories/stale", {
         days: options?.days,
+        pinned: options?.pinned,
         project_id: options?.project_id,
         agent_id: options?.agent_id,
         limit,