@remnic/plugin-openclaw 1.0.9 → 1.0.11

package/dist/chunk-B52XADV3.js

@@ -0,0 +1,244 @@
+import {
+  gatherConsoleState
+} from "./chunk-MBIFE6SA.js";
+
+// ../remnic-core/src/console/tui.ts
+var ANSI_CLEAR_HOME = "\x1B[2J\x1B[H";
+var ANSI_HIDE_CURSOR = "\x1B[?25l";
+var ANSI_SHOW_CURSOR = "\x1B[?25h";
+var FRAME_INNER_WIDTH = 70;
+var DEFAULT_REFRESH_INTERVAL_MS = 2e3;
+function runConsoleTui(orchestrator, options = {}) {
+  const refreshIntervalMs = Math.max(
+    50,
+    options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS
+  );
+  const output = options.output ?? process.stdout;
+  const now = options.now ?? (() => Date.now());
+  const installSigintHandler = options.installSigintHandler ?? true;
+  let stopped = false;
+  let inFlight = false;
+  let inFlightTickPromise = null;
+  let traceWritePending = false;
+  let traceFramesDropped = 0;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  safeWrite(output, ANSI_HIDE_CURSOR);
+  const tick = async () => {
+    if (stopped || inFlight) return;
+    inFlight = true;
+    try {
+      let snapshot = null;
+      let renderError = null;
+      try {
+        snapshot = await gatherConsoleState(orchestrator);
+      } catch (err) {
+        renderError = describeError(err);
+      }
+      if (stopped) return;
+      let frame;
+      try {
+        frame = renderFrame({ snapshot, renderError, now });
+      } catch (err) {
+        frame = `remnic console: render failed: ${describeError(err)}
+`;
+      }
+      safeWrite(output, ANSI_CLEAR_HOME);
+      safeWrite(output, frame);
+      if (snapshot && options.traceRecorder && !traceWritePending) {
+        traceWritePending = true;
+        void options.traceRecorder.append(snapshot).catch(() => {
+        }).finally(() => {
+          traceWritePending = false;
+        });
+      } else if (snapshot && options.traceRecorder) {
+        traceFramesDropped += 1;
+      }
+    } finally {
+      inFlight = false;
+    }
+  };
+  const launchTick = () => {
+    const p = runTickSafely(tick);
+    inFlightTickPromise = p;
+    void p.then(() => {
+      if (inFlightTickPromise === p) {
+        inFlightTickPromise = null;
+      }
+    });
+  };
+  launchTick();
+  const handle = setInterval(launchTick, refreshIntervalMs);
+  const sigintHandler = () => {
+    stop();
+  };
+  if (installSigintHandler) {
+    process.on("SIGINT", sigintHandler);
+  }
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(handle);
+    if (installSigintHandler) {
+      try {
+        process.removeListener("SIGINT", sigintHandler);
+      } catch {
+      }
+    }
+    safeWrite(output, ANSI_SHOW_CURSOR);
+    void (async () => {
+      try {
+        const pendingTick = inFlightTickPromise;
+        if (pendingTick) {
+          await pendingTick;
+        }
+      } finally {
+        resolveDone();
+      }
+    })();
+  };
+  return {
+    stop,
+    done,
+    getDroppedTraceFrames: () => traceFramesDropped
+  };
+}
+function renderFrame(input) {
+  const ts = new Date(input.now()).toISOString();
+  const lines = [];
+  lines.push(renderHeader(ts));
+  for (const panel of renderPanels(input)) {
+    lines.push(panel);
+  }
+  lines.push(renderFooter());
+  return lines.join("\n") + "\n";
+}
+function renderHeader(ts) {
+  const title = " remnic console ";
+  const trailing = ` ${ts} `;
+  const fillerLen = Math.max(
+    1,
+    FRAME_INNER_WIDTH - title.length - trailing.length
+  );
+  const filler = "\u2550".repeat(fillerLen);
+  return `\u2554${title}${filler}${trailing}\u2557`;
+}
+function renderFooter() {
+  return `\u255A${"\u2550".repeat(FRAME_INNER_WIDTH)}\u255D`;
+}
+function renderPanels(input) {
+  const lines = [];
+  const snap = input.snapshot;
+  if (input.renderError !== null) {
+    lines.push(panelLine("Error", `refresh failed: ${input.renderError}`));
+    lines.push(panelLine("Buffer", "(unavailable)"));
+    lines.push(panelLine("Extraction", "(unavailable)"));
+    lines.push(panelLine("Dedup", "(unavailable)"));
+    lines.push(panelLine("Maintenance", "(unavailable)"));
+    lines.push(panelLine("QMD", "(unavailable)"));
+    return lines;
+  }
+  if (snap) {
+    lines.push(
+      panelLine(
+        "Buffer",
+        `turns=${snap.bufferState.turnsCount} bytes=${snap.bufferState.byteCount}`
+      )
+    );
+    const verdicts = snap.extractionQueue.recentVerdicts;
+    const accepts = verdicts.filter((v) => v.kind === "accept").length;
+    const rejects = verdicts.filter((v) => v.kind === "reject").length;
+    lines.push(
+      panelLine(
+        "Extraction",
+        `queue=${snap.extractionQueue.depth}  recent verdicts: accept(${accepts})/reject(${rejects})`
+      )
+    );
+    const dedupSummary = formatDedupSummary(snap.dedupRecent, input.now);
+    lines.push(panelLine("Dedup", dedupSummary));
+    const maintSummary = formatMaintenanceTail(snap.maintenanceLedgerTail);
+    lines.push(panelLine("Maintenance", maintSummary));
+    lines.push(panelLine("QMD", formatQmdSummary(snap)));
+  }
+  if (snap && snap.errors.length > 0) {
+    const head = snap.errors[0];
+    lines.push(panelLine("Errors", head ?? ""));
+  }
+  return lines;
+}
+function formatDedupSummary(decisions, now) {
+  if (decisions.length === 0) return "no recent decisions";
+  const last = decisions[decisions.length - 1];
+  if (!last) return "no recent decisions";
+  const ageMs = ageMsFromIso(last.ts, now);
+  const ageStr = ageMs === null ? "T-?" : `T-${Math.round(ageMs / 1e3)}s`;
+  const fp = last.fingerprint ? `hash=${last.fingerprint}` : "hash=?";
+  return `recent: ${fp} decision=${last.decision} (${ageStr})`;
+}
+function formatMaintenanceTail(events) {
+  if (events.length === 0) return "no events";
+  const last = events[events.length - 1];
+  if (!last) return "no events";
+  return `n=${events.length}  last: ${last.category} ${truncate(last.summary, 40)}`;
+}
+function formatQmdSummary(snap) {
+  const probe = snap.qmdProbe.available ? "ok" : "down";
+  const uptimeH = snap.daemon.uptimeMs / 36e5;
+  const uptimeStr = uptimeH < 1 ? `${Math.round(snap.daemon.uptimeMs / 1e3)}s` : `${uptimeH.toFixed(1)}h`;
+  const mode = snap.qmdProbe.daemonMode ? "daemon" : "cli";
+  return `probe=${probe}  mode=${mode}  uptime=${uptimeStr}`;
+}
+function panelLine(label, value) {
+  const LABEL_WIDTH = 13;
+  const labelCol = padRight(label, LABEL_WIDTH);
+  const remaining = FRAME_INNER_WIDTH - LABEL_WIDTH - 2;
+  const valueCol = padRight(truncate(value, remaining), remaining);
+  return `\u2551 ${labelCol}${valueCol} \u2551`;
+}
+function padRight(s, width) {
+  if (s.length >= width) return s;
+  return s + " ".repeat(width - s.length);
+}
+function truncate(s, max) {
+  if (max <= 0) return "";
+  if (s.length <= max) return s;
+  if (max <= 1) return s.slice(0, max);
+  return s.slice(0, max - 1) + "\u2026";
+}
+function ageMsFromIso(iso, now) {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return null;
+  const delta = now() - ms;
+  return delta < 0 ? 0 : delta;
+}
+async function runTickSafely(tick) {
+  try {
+    await tick();
+  } catch {
+  }
+}
+function safeWrite(output, chunk) {
+  try {
+    output.write(chunk);
+  } catch {
+  }
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  try {
+    return String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+
+export {
+  runConsoleTui,
+  renderFrame,
+  stripAnsi
+};

package/dist/chunk-BU5KJVWF.js

@@ -0,0 +1,78 @@
+// ../remnic-core/src/tier-migration.ts
+import { appendFile, mkdir } from "fs/promises";
+import path from "path";
+var TierMigrationExecutor = class {
+  storage;
+  qmd;
+  hotCollection;
+  coldCollection;
+  autoEmbed;
+  journalPath;
+  constructor(options) {
+    this.storage = options.storage;
+    this.qmd = options.qmd;
+    this.hotCollection = options.hotCollection;
+    this.coldCollection = options.coldCollection;
+    this.autoEmbed = options.autoEmbed === true;
+    this.journalPath = options.journalPath ?? path.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
+  }
+  async migrateMemory(request) {
+    const { memory, fromTier, toTier, reason } = request;
+    const targetPath = this.storage.buildTierMemoryPath(memory, toTier);
+    if (fromTier === toTier) {
+      const noChange = {
+        memoryId: memory.frontmatter.id,
+        fromTier,
+        toTier,
+        changed: false,
+        reason,
+        targetPath
+      };
+      await this.appendJournal(noChange);
+      return noChange;
+    }
+    const moved = await this.storage.migrateMemoryToTier(memory, toTier);
+    const result = {
+      memoryId: memory.frontmatter.id,
+      fromTier,
+      toTier,
+      changed: moved.changed,
+      reason,
+      targetPath: moved.targetPath
+    };
+    await this.appendJournal(result);
+    if (result.changed) {
+      const destinationCollection = this.collectionForTier(toTier);
+      const sourceCollection = this.collectionForTier(fromTier);
+      await this.qmd.updateCollection(destinationCollection);
+      if (this.autoEmbed) {
+        await this.qmd.embedCollection(destinationCollection);
+        if (sourceCollection !== destinationCollection) {
+          await this.qmd.embedCollection(sourceCollection);
+        }
+      }
+    }
+    return result;
+  }
+  collectionForTier(tier) {
+    return tier === "cold" ? this.coldCollection : this.hotCollection;
+  }
+  async appendJournal(result) {
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      memoryId: result.memoryId,
+      fromTier: result.fromTier,
+      toTier: result.toTier,
+      changed: result.changed,
+      reason: result.reason,
+      targetPath: result.targetPath
+    };
+    await mkdir(path.dirname(this.journalPath), { recursive: true });
+    await appendFile(this.journalPath, `${JSON.stringify(entry)}
+`, "utf-8");
+  }
+};
+
+export {
+  TierMigrationExecutor
+};

package/dist/chunk-CXM7EBAO.js

@@ -0,0 +1,289 @@
+import {
+  buildMetadata,
+  decodeMetadataSalt,
+  parseMetadata,
+  serializeMetadata
+} from "./chunk-JZBOXOUC.js";
+import {
+  KDF_KEY_LENGTH,
+  KDF_SALT_LENGTH,
+  deriveKey
+} from "./chunk-6IWEAUN6.js";
+import {
+  open,
+  seal
+} from "./chunk-YGGGUTG3.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/secure-store/header.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var SECURE_STORE_DIR_NAME = ".secure-store";
+var HEADER_FILENAME = "header.json";
+var HEADER_FORMAT = "remnic.secure-store.header";
+var HEADER_FORMAT_VERSION = 1;
+var VERIFIER_PLAINTEXT = Buffer.from("remnic-secure-store-v1", "utf8");
+var VERIFIER_AAD = Buffer.from("remnic-secure-store/verifier", "utf8");
+function secureStoreDir(memoryDir) {
+  return path.join(memoryDir, SECURE_STORE_DIR_NAME);
+}
+function headerPath(memoryDir) {
+  return path.join(secureStoreDir(memoryDir), HEADER_FILENAME);
+}
+function buildHeader(options) {
+  const { metadata, derivedKey } = options;
+  if (!Buffer.isBuffer(derivedKey) || derivedKey.length !== KDF_KEY_LENGTH) {
+    throw new Error(
+      `derivedKey must be a ${KDF_KEY_LENGTH}-byte Buffer, got length=${derivedKey?.length ?? "non-buffer"}`
+    );
+  }
+  const salt = decodeMetadataSalt(metadata);
+  if (salt.length !== KDF_SALT_LENGTH) {
+    throw new Error(`metadata salt is ${salt.length} bytes, expected ${KDF_SALT_LENGTH}`);
+  }
+  const envelope = seal(derivedKey, salt, VERIFIER_PLAINTEXT, { aad: VERIFIER_AAD });
+  return {
+    format: HEADER_FORMAT,
+    formatVersion: HEADER_FORMAT_VERSION,
+    metadata,
+    verifier: envelope.toString("hex"),
+    createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function serializeHeader(header) {
+  validateHeader(header);
+  const metadataString = serializeMetadata(header.metadata);
+  const metadataObject = JSON.parse(metadataString);
+  const ordered = {
+    format: header.format,
+    formatVersion: header.formatVersion,
+    metadata: metadataObject,
+    verifier: header.verifier,
+    createdAt: header.createdAt
+  };
+  return JSON.stringify(ordered, null, 2);
+}
+function parseHeader(json) {
+  if (typeof json !== "string") {
+    throw new Error("header input must be a string");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`header is not valid JSON: ${msg}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("header must be a JSON object");
+  }
+  const obj = parsed;
+  if (obj.format !== HEADER_FORMAT) {
+    throw new Error(
+      `unexpected header format: ${String(obj.format)} (expected ${HEADER_FORMAT})`
+    );
+  }
+  if (obj.formatVersion !== HEADER_FORMAT_VERSION) {
+    throw new Error(
+      `unsupported header formatVersion: ${String(obj.formatVersion)} (this build supports ${HEADER_FORMAT_VERSION})`
+    );
+  }
+  if (typeof obj.verifier !== "string" || obj.verifier.length === 0) {
+    throw new Error("header.verifier must be a non-empty hex string");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(obj.verifier)) {
+    throw new Error("header.verifier must be a hex-encoded string");
+  }
+  if (obj.verifier.length % 2 !== 0) {
+    throw new Error(
+      "header.verifier hex string must have even length (each byte encodes as two hex digits)"
+    );
+  }
+  if (typeof obj.createdAt !== "string" || obj.createdAt.length === 0) {
+    throw new Error("header.createdAt must be a non-empty string");
+  }
+  if (typeof obj.metadata !== "object" || obj.metadata === null) {
+    throw new Error("header.metadata must be an object");
+  }
+  const metadata = parseMetadata(JSON.stringify(obj.metadata));
+  const header = {
+    format: HEADER_FORMAT,
+    formatVersion: HEADER_FORMAT_VERSION,
+    metadata,
+    verifier: obj.verifier,
+    createdAt: obj.createdAt
+  };
+  validateHeader(header);
+  return header;
+}
+function validateHeader(header) {
+  if (header.format !== HEADER_FORMAT) {
+    throw new Error(`header.format must be ${HEADER_FORMAT}`);
+  }
+  if (header.formatVersion !== HEADER_FORMAT_VERSION) {
+    throw new Error(`header.formatVersion must be ${HEADER_FORMAT_VERSION}`);
+  }
+  if (typeof header.createdAt !== "string" || header.createdAt.length === 0) {
+    throw new Error("header.createdAt must be a non-empty ISO-8601 string");
+  }
+  if (typeof header.verifier !== "string" || header.verifier.length === 0) {
+    throw new Error("header.verifier must be a non-empty hex string");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(header.verifier)) {
+    throw new Error("header.verifier must be a hex-encoded string");
+  }
+  if (header.verifier.length % 2 !== 0) {
+    throw new Error(
+      "header.verifier hex string must have even length (each byte encodes as two hex digits)"
+    );
+  }
+  if (header.metadata.format !== "remnic.secure-store.metadata") {
+    throw new Error("header.metadata.format must be remnic.secure-store.metadata");
+  }
+}
+function verifyKey(header, candidateKey) {
+  if (!Buffer.isBuffer(candidateKey) || candidateKey.length !== KDF_KEY_LENGTH) {
+    return false;
+  }
+  const envelope = Buffer.from(header.verifier, "hex");
+  try {
+    const plaintext = open(candidateKey, envelope, { aad: VERIFIER_AAD });
+    return plaintext.equals(VERIFIER_PLAINTEXT);
+  } catch {
+    return false;
+  }
+}
+function deriveKeyFromHeader(header, passphrase) {
+  const salt = decodeMetadataSalt(header.metadata);
+  const params = header.metadata.kdf.params;
+  return deriveKey(header.metadata.kdf.algorithm, passphrase, salt, params);
+}
+async function readHeader(memoryDir) {
+  const target = headerPath(memoryDir);
+  let raw;
+  try {
+    raw = await readFile(target, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return null;
+    }
+    throw e;
+  }
+  return parseHeader(raw);
+}
+async function writeHeader(memoryDir, header) {
+  validateHeader(header);
+  const dir = secureStoreDir(memoryDir);
+  await mkdir(dir, { recursive: true });
+  const target = headerPath(memoryDir);
+  try {
+    await writeFile(target, serializeHeader(header), {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+  } catch (e) {
+    if (e.code === "EEXIST") {
+      throw new Error(
+        `secure-store header already exists at ${target}. Refusing to overwrite \u2014 initialize a fresh store or remove the existing header explicitly.`
+      );
+    }
+    throw e;
+  }
+  return target;
+}
+function buildHeaderFromPassphrase(options) {
+  const { passphrase, salt } = options;
+  const algorithm = options.algorithm ?? "argon2id";
+  const metadataOpts = { algorithm, salt };
+  if (options.params !== void 0) metadataOpts.params = options.params;
+  if (options.createdAt !== void 0) metadataOpts.createdAt = options.createdAt;
+  if (options.note !== void 0) metadataOpts.note = options.note;
+  const metadata = buildMetadata(metadataOpts);
+  const params = metadata.kdf.params;
+  const derivedKey = deriveKey(algorithm, passphrase, salt, params);
+  const headerOpts = {
+    metadata,
+    derivedKey
+  };
+  if (options.createdAt !== void 0) headerOpts.createdAt = options.createdAt;
+  const header = buildHeader(headerOpts);
+  return { header, derivedKey };
+}
+
+// ../remnic-core/src/secure-store/keyring.ts
+var keyring_exports = {};
+__export(keyring_exports, {
+  getKey: () => getKey,
+  lock: () => lock,
+  lockAll: () => lockAll,
+  size: () => size,
+  status: () => status,
+  unlock: () => unlock
+});
+var ENTRIES = /* @__PURE__ */ new Map();
+function unlock(id, key, now = () => /* @__PURE__ */ new Date()) {
+  if (typeof id !== "string" || id.length === 0) {
+    throw new Error("keyring id must be a non-empty string");
+  }
+  if (!Buffer.isBuffer(key) || key.length !== 32) {
+    throw new Error(`keyring key must be a 32-byte Buffer, got length=${key?.length ?? "non-buffer"}`);
+  }
+  const existing = ENTRIES.get(id);
+  if (existing) {
+    existing.key.fill(0);
+  }
+  ENTRIES.set(id, { key, unlockedAt: now().toISOString() });
+}
+function getKey(id) {
+  const entry = ENTRIES.get(id);
+  return entry ? entry.key : null;
+}
+function lock(id) {
+  const entry = ENTRIES.get(id);
+  if (!entry) return false;
+  entry.key.fill(0);
+  ENTRIES.delete(id);
+  return true;
+}
+function lockAll() {
+  for (const entry of ENTRIES.values()) {
+    entry.key.fill(0);
+  }
+  ENTRIES.clear();
+}
+function status(id) {
+  const entry = ENTRIES.get(id);
+  if (!entry) {
+    return { unlocked: false, unlockedAt: null };
+  }
+  return { unlocked: true, unlockedAt: entry.unlockedAt };
+}
+function size() {
+  return ENTRIES.size;
+}
+
+export {
+  SECURE_STORE_DIR_NAME,
+  HEADER_FILENAME,
+  HEADER_FORMAT,
+  HEADER_FORMAT_VERSION,
+  secureStoreDir,
+  headerPath,
+  buildHeader,
+  serializeHeader,
+  parseHeader,
+  validateHeader,
+  verifyKey,
+  deriveKeyFromHeader,
+  readHeader,
+  writeHeader,
+  buildHeaderFromPassphrase,
+  unlock,
+  getKey,
+  lock,
+  status,
+  keyring_exports
+};