@remnic/plugin-openclaw 1.0.9 → 1.0.11

package/dist/capsule-merge-7RVOHJK3.js

@@ -0,0 +1,189 @@
+import {
+  parseExportBundle
+} from "./chunk-K7EUBNDD.js";
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  sha256String
+} from "./chunk-NKVIN6RD.js";
+import "./chunk-XMSDA5WA.js";
+import {
+  createVersion
+} from "./chunk-6OJAU466.js";
+import "./chunk-MLKGABMK.js";
+
+// ../remnic-core/src/transfer/capsule-merge.ts
+import { lstat, mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
+import path from "path";
+import { gunzipSync } from "zlib";
+async function mergeCapsule(opts) {
+  const archiveAbs = path.resolve(opts.sourceArchive);
+  const rootAbs = path.resolve(opts.targetRoot);
+  await assertIsDirectoryNotSymlink(rootAbs, "mergeCapsule", "targetRoot");
+  const conflictMode = opts.conflictMode ?? "skip-conflicts";
+  if (conflictMode !== "skip-conflicts" && conflictMode !== "prefer-source" && conflictMode !== "prefer-local") {
+    throw new Error(
+      `mergeCapsule: unknown conflictMode ${JSON.stringify(conflictMode)}; expected "skip-conflicts", "prefer-source", or "prefer-local"`
+    );
+  }
+  const raw = await readFile(archiveAbs);
+  let json;
+  try {
+    json = gunzipSync(raw).toString("utf-8");
+  } catch (cause) {
+    throw new Error(
+      `mergeCapsule: archive is not a valid gzip file: ${archiveAbs}`,
+      { cause }
+    );
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(json);
+  } catch (cause) {
+    throw new Error(
+      `mergeCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,
+      { cause }
+    );
+  }
+  const parsed = parseExportBundle(parsedJson);
+  if (parsed.capsuleVersion !== 2) {
+    throw new Error(
+      "mergeCapsule: archive is V1; only V2 capsule archives are supported"
+    );
+  }
+  const bundle = parsed.bundle;
+  const manifest = bundle.manifest;
+  const capsule = manifest.capsule;
+  const manifestIndex = /* @__PURE__ */ new Map();
+  for (const f of manifest.files) {
+    manifestIndex.set(f.path, f);
+  }
+  if (manifestIndex.size !== manifest.files.length) {
+    throw new Error("mergeCapsule: manifest contains duplicate file paths");
+  }
+  const recordPaths = /* @__PURE__ */ new Set();
+  for (const rec of bundle.records) {
+    if (recordPaths.has(rec.path)) {
+      throw new Error(
+        `mergeCapsule: bundle contains duplicate record path: ${rec.path}`
+      );
+    }
+    recordPaths.add(rec.path);
+  }
+  const rootReal = await realpath(rootAbs).catch(() => rootAbs);
+  const seenTargetPaths = /* @__PURE__ */ new Map();
+  for (const rec of bundle.records) {
+    const entry = manifestIndex.get(rec.path);
+    if (!entry) {
+      throw new Error(
+        `mergeCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`
+      );
+    }
+    const { sha256, bytes } = sha256String(rec.content);
+    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {
+      throw new Error(
+        `mergeCapsule: archive checksum mismatch for ${rec.path}: expected sha256=${entry.sha256} bytes=${entry.bytes}, got sha256=${sha256} bytes=${bytes}`
+      );
+    }
+    if (rec.path.includes("\\")) {
+      throw new Error(
+        `mergeCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`
+      );
+    }
+    const posixNormalized = path.posix.normalize(rec.path);
+    if (rec.path.startsWith("/") || rec.path.split("/").some((seg) => seg === "..") || posixNormalized.startsWith("..") || posixNormalized.startsWith("/")) {
+      throw new Error(
+        `mergeCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    const targetAbs = path.join(rootReal, fromPosixRelPath(rec.path));
+    if (!isPathInsideRoot(rootReal, targetAbs)) {
+      throw new Error(
+        `mergeCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, "mergeCapsule");
+    const targetLstat = await lstat(targetAbs).catch(() => null);
+    if (targetLstat !== null && targetLstat.isSymbolicLink()) {
+      throw new Error(
+        `mergeCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`
+      );
+    }
+    const dedupKey = targetAbs.toLowerCase();
+    const firstSourcePath = seenTargetPaths.get(dedupKey);
+    if (firstSourcePath !== void 0) {
+      throw new Error(
+        `mergeCapsule: manifest contains two entries that resolve to the same target path: "${firstSourcePath}" and "${rec.path}" both map to "${rec.path}"`
+      );
+    }
+    seenTargetPaths.set(dedupKey, rec.path);
+  }
+  for (const f of manifest.files) {
+    if (!recordPaths.has(f.path)) {
+      throw new Error(
+        `mergeCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`
+      );
+    }
+  }
+  const merged = [];
+  const skipped = [];
+  const conflicts = [];
+  const sortedRecords = [...bundle.records].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  for (const rec of sortedRecords) {
+    const targetAbs = path.join(rootReal, fromPosixRelPath(rec.path));
+    const entry = manifestIndex.get(rec.path);
+    const localContent = await readLocalFile(targetAbs);
+    if (localContent === null) {
+      await mkdir(path.dirname(targetAbs), { recursive: true });
+      await writeFile(targetAbs, rec.content, "utf-8");
+      merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted: false });
+      continue;
+    }
+    const { sha256: localSha256 } = sha256String(localContent);
+    if (localSha256 === entry.sha256) {
+      skipped.push({ path: rec.path, reason: "identical" });
+      continue;
+    }
+    const { sha256: archiveSha256 } = sha256String(rec.content);
+    conflicts.push({
+      path: rec.path,
+      archiveSha256,
+      localSha256
+    });
+    if (conflictMode === "skip-conflicts" || conflictMode === "prefer-local") {
+      skipped.push({ path: rec.path, reason: "conflict" });
+      continue;
+    }
+    let snapshotted = false;
+    if (opts.versioning && opts.versioning.enabled) {
+      await createVersion(
+        targetAbs,
+        localContent,
+        "manual",
+        opts.versioning,
+        opts.log,
+        `capsule-merge: ${capsule.id}`,
+        rootReal
+      );
+      snapshotted = true;
+    }
+    await writeFile(targetAbs, rec.content, "utf-8");
+    merged.push({ sourcePath: rec.path, targetPath: rec.path, snapshotted });
+  }
+  merged.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
+  skipped.sort((a, b) => a.path.localeCompare(b.path));
+  conflicts.sort((a, b) => a.path.localeCompare(b.path));
+  return { merged, skipped, conflicts, manifest };
+}
+async function readLocalFile(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  if (!st || !st.isFile()) return null;
+  return readFile(absPath, "utf-8");
+}
+export {
+  mergeCapsule
+};

package/dist/{causal-chain-OKDZSDEB.js → causal-chain-WYN5QOPS.js}

@@ -6,8 +6,9 @@ import {
   stitchCausalChain,
   validateCausalEdge,
   writeChainIndex
-} from "./chunk-BXTMZDRT.js";
-import "./chunk-YHH3SXKD.js";
+} from "./chunk-SVSQAG6M.js";
+import "./chunk-WPINX4MF.js";
+import "./chunk-3G7FAF6S.js";
 import "./chunk-5LE4HTVL.js";
 import "./chunk-UFU5GGGA.js";
 import "./chunk-MLKGABMK.js";

package/dist/{causal-consolidation-5BEXLQV5.js → causal-consolidation-JD6KJJH6.js}

@@ -1,27 +1,31 @@
-import {
-  buildExtensionsBlockForConsolidation,
-  runPostConsolidationMaterialize
-} from "./chunk-S2ISS4AH.js";
-import {
-  FallbackLlmClient
-} from "./chunk-7TENHBV2.js";
-import "./chunk-3A5ELHTT.js";
-import "./chunk-JJSNPSCD.js";
-import "./chunk-6OJAU466.js";
 import {
   readChainIndex,
   resolveChainsDir
-} from "./chunk-BXTMZDRT.js";
+} from "./chunk-SVSQAG6M.js";
+import {
+  buildExtensionsBlockForConsolidation,
+  runPostConsolidationMaterialize
+} from "./chunk-P3DIW2SD.js";
+import "./chunk-WPINX4MF.js";
 import {
   isRecord
-} from "./chunk-YHH3SXKD.js";
+} from "./chunk-3G7FAF6S.js";
 import {
   listJsonFiles,
   readJsonFile
 } from "./chunk-5LE4HTVL.js";
+import {
+  FallbackLlmClient
+} from "./chunk-RQCTMECT.js";
+import "./chunk-3A5ELHTT.js";
+import "./chunk-TNH24SF6.js";
+import "./chunk-6OJAU466.js";
+import "./chunk-3I7RHWYT.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
+import "./chunk-YGGGUTG3.js";
+import "./chunk-I6B2W2IY.js";
 import "./chunk-MLKGABMK.js";
 
 // ../remnic-core/src/causal-consolidation.ts

package/dist/{causal-retrieval-3BKBXVXD.js → causal-retrieval-NZHQOZOE.js}

@@ -1,11 +1,12 @@
-import {
-  searchCausalTrajectories
-} from "./chunk-LN5UZQVG.js";
 import {
   readChainIndex,
   resolveChainsDir
-} from "./chunk-BXTMZDRT.js";
-import "./chunk-YHH3SXKD.js";
+} from "./chunk-SVSQAG6M.js";
+import {
+  searchCausalTrajectories
+} from "./chunk-6UFI73TJ.js";
+import "./chunk-WPINX4MF.js";
+import "./chunk-3G7FAF6S.js";
 import "./chunk-5LE4HTVL.js";
 import {
   log

package/dist/{causal-trajectory-graph-RQIT37DN.js → causal-trajectory-graph-VBPE2WPM.js}

@@ -1,6 +1,6 @@
 import {
   appendEdge
-} from "./chunk-Z7GRLVK3.js";
+} from "./chunk-3GUF7RQI.js";
 import "./chunk-MLKGABMK.js";
 
 // ../remnic-core/src/causal-trajectory-graph.ts

package/dist/chunk-37NKFWSO.js

@@ -0,0 +1,233 @@
+import {
+  expandTildePath
+} from "./chunk-OEI7GLV2.js";
+
+// ../remnic-core/src/connectors/live/state-store.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// ../remnic-core/src/connectors/live/framework.ts
+var CONNECTOR_ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+function isValidConnectorId(id) {
+  return typeof id === "string" && CONNECTOR_ID_PATTERN.test(id);
+}
+
+// ../remnic-core/src/connectors/live/state-store.ts
+var STATE_DIR_NAME = "state";
+var CONNECTORS_DIR_NAME = "connectors";
+var MAX_ERROR_LENGTH = 1024;
+var VALID_SYNC_STATUSES = /* @__PURE__ */ new Set([
+  "success",
+  "error",
+  "never"
+]);
+var ConnectorStateCorruptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorStateCorruptionError";
+  }
+};
+function resolveConnectorsDir(memoryDir) {
+  if (typeof memoryDir !== "string" || memoryDir.length === 0) {
+    throw new TypeError("memoryDir must be a non-empty string");
+  }
+  return path.join(expandTildePath(memoryDir), STATE_DIR_NAME, CONNECTORS_DIR_NAME);
+}
+function resolveConnectorStatePath(memoryDir, id) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  return path.join(resolveConnectorsDir(memoryDir), `${id}.json`);
+}
+function isConnectorStateShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.id !== "string") return false;
+  if (typeof v.lastSyncStatus !== "string") return false;
+  if (!["success", "error", "never"].includes(v.lastSyncStatus)) return false;
+  if (typeof v.totalDocsImported !== "number" || !Number.isInteger(v.totalDocsImported)) return false;
+  if (v.totalDocsImported < 0) return false;
+  if (typeof v.updatedAt !== "string") return false;
+  if (v.lastSyncAt !== null && typeof v.lastSyncAt !== "string") return false;
+  if (v.cursor !== null) {
+    if (typeof v.cursor !== "object" || v.cursor === null) return false;
+    const c = v.cursor;
+    if (typeof c.kind !== "string" || typeof c.value !== "string" || typeof c.updatedAt !== "string") {
+      return false;
+    }
+  }
+  if (v.lastSyncError !== void 0 && typeof v.lastSyncError !== "string") return false;
+  return true;
+}
+async function assertNoSymlinkOnPath(memoryDir, filePath) {
+  const expandedRoot = expandTildePath(memoryDir);
+  const root = path.resolve(expandedRoot);
+  const target = path.resolve(filePath);
+  const rel = path.relative(root, target);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(
+      `connector state path ${target} escapes memory root ${root}`
+    );
+  }
+  const segments = rel.length === 0 ? [] : rel.split(path.sep);
+  let current = root;
+  const componentsToCheck = [current];
+  for (const seg of segments) {
+    current = path.join(current, seg);
+    componentsToCheck.push(current);
+  }
+  for (const component of componentsToCheck) {
+    let stat;
+    try {
+      stat = await fs.lstat(component);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    if (stat.isSymbolicLink()) {
+      throw new Error(
+        `connector state path component ${component} is a symlink; refusing to follow`
+      );
+    }
+  }
+}
+async function readConnectorState(memoryDir, id) {
+  const filePath = resolveConnectorStatePath(memoryDir, id);
+  await assertNoSymlinkOnPath(memoryDir, filePath);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} is not valid JSON: ${err.message}`
+    );
+  }
+  if (!isConnectorStateShape(parsed)) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} does not match ConnectorState shape`
+    );
+  }
+  if (parsed.id !== id) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} has mismatched id ${JSON.stringify(parsed.id)}; expected ${JSON.stringify(id)}`
+    );
+  }
+  return parsed;
+}
+async function writeConnectorState(memoryDir, id, state) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  if (state.id !== id) {
+    throw new Error(
+      `writeConnectorState(): state.id ${JSON.stringify(state.id)} does not match id argument ${JSON.stringify(id)}`
+    );
+  }
+  if (!VALID_SYNC_STATUSES.has(state.lastSyncStatus)) {
+    throw new Error(
+      `writeConnectorState(): lastSyncStatus must be one of ${[...VALID_SYNC_STATUSES].join(", ")}, got ${JSON.stringify(state.lastSyncStatus)}`
+    );
+  }
+  if (state.lastSyncAt !== null && typeof state.lastSyncAt !== "string") {
+    throw new Error(
+      `writeConnectorState(): lastSyncAt must be a string or null, got ${typeof state.lastSyncAt}`
+    );
+  }
+  if (state.cursor !== null) {
+    if (typeof state.cursor !== "object") {
+      throw new Error(`writeConnectorState(): cursor must be an object or null`);
+    }
+    if (typeof state.cursor.kind !== "string" || typeof state.cursor.value !== "string" || typeof state.cursor.updatedAt !== "string") {
+      throw new Error(
+        `writeConnectorState(): cursor must have string kind, value, and updatedAt`
+      );
+    }
+  }
+  if (typeof state.totalDocsImported !== "number" || !Number.isInteger(state.totalDocsImported) || state.totalDocsImported < 0) {
+    throw new Error(
+      `writeConnectorState(): totalDocsImported must be a non-negative integer`
+    );
+  }
+  if (state.lastSyncError !== void 0 && typeof state.lastSyncError !== "string") {
+    throw new Error(`writeConnectorState(): lastSyncError must be a string when provided`);
+  }
+  const truncatedError = state.lastSyncError !== void 0 && state.lastSyncError.length > MAX_ERROR_LENGTH ? state.lastSyncError.slice(0, MAX_ERROR_LENGTH) : state.lastSyncError;
+  const finalState = {
+    id: state.id,
+    cursor: state.cursor,
+    lastSyncAt: state.lastSyncAt,
+    lastSyncStatus: state.lastSyncStatus,
+    ...truncatedError !== void 0 ? { lastSyncError: truncatedError } : {},
+    totalDocsImported: state.totalDocsImported,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const dir = resolveConnectorsDir(memoryDir);
+  const targetPath = path.join(dir, `${id}.json`);
+  await assertNoSymlinkOnPath(memoryDir, targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const body = `${JSON.stringify(finalState, null, 2)}
+`;
+  try {
+    await fs.writeFile(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    await fs.rename(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return finalState;
+}
+async function listConnectorStates(memoryDir) {
+  const dir = resolveConnectorsDir(memoryDir);
+  await assertNoSymlinkOnPath(memoryDir, dir);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const id = entry.slice(0, -".json".length);
+    if (!isValidConnectorId(id)) continue;
+    try {
+      const state = await readConnectorState(memoryDir, id);
+      if (state !== null) out.push(state);
+    } catch (err) {
+      if (err instanceof ConnectorStateCorruptionError) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  out.sort((a, b) => a.id.localeCompare(b.id));
+  return out;
+}
+function _connectorStatePathForTest(memoryDir, id) {
+  return resolveConnectorStatePath(memoryDir, id);
+}
+
+export {
+  readConnectorState,
+  writeConnectorState,
+  listConnectorStates,
+  _connectorStatePathForTest
+};

package/dist/chunk-3G7FAF6S.js

@@ -0,0 +1,60 @@
+// ../remnic-core/src/store-contract.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function optionalString(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return void 0;
+  return value.trim();
+}
+function assertSafePathSegment(value, field) {
+  if (value === "." || value === ".." || value.includes("/") || value.includes("\\")) {
+    throw new Error(`${field} must be a safe path segment`);
+  }
+  return value;
+}
+function assertIsoRecordedAt(value, field = "recordedAt") {
+  if (!/^\d{4}-\d{2}-\d{2}T/.test(value)) {
+    throw new Error(`${field} must be an ISO timestamp`);
+  }
+  return value;
+}
+function recordStoreDay(recordedAt) {
+  const day = recordedAt.slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) {
+    throw new Error("recordedAt must start with a valid YYYY-MM-DD date");
+  }
+  return day;
+}
+function optionalStringArray(value, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array of strings`);
+  const items = value.map((item, index) => assertString(item, `${field}[${index}]`));
+  return items.length > 0 ? items : void 0;
+}
+function validateStringRecord(raw, field = "metadata") {
+  if (raw === void 0) return void 0;
+  if (!isRecord(raw)) throw new Error(`${field} must be an object of strings`);
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value !== "string") throw new Error(`${field} must be an object of strings`);
+    out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+export {
+  isRecord,
+  assertString,
+  optionalString,
+  assertSafePathSegment,
+  assertIsoRecordedAt,
+  recordStoreDay,
+  optionalStringArray,
+  validateStringRecord
+};