@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/chunk-MXFJXUHC.js

@@ -1,292 +0,0 @@
-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-I2KLQ2HA.js";
-
-// ../remnic-core/src/secure-store/header.ts
-import * as fsReadModule0 from "fs/promises";
-const mkdir = fsReadModule0.mkdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const writeFile = fsReadModule0.writeFile;
-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 fileReader(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
-};

package/dist/chunk-NUWDSTP7.js

@@ -1,233 +0,0 @@
-import {
-  expandTildePath
-} from "./chunk-EH4AXGRO.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["re"+"ad"+"Fi"+"le"](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
-};