@remnic/plugin-openclaw 1.0.10 → 1.0.11

package/dist/chunk-I6B2W2IY.js

@@ -0,0 +1,47 @@
+// ../remnic-core/src/runtime/env.ts
+import os from "os";
+var REMNIC_ENGRAM_PREFIX_PAIRS = [
+  ["REMNIC_", "ENGRAM_"],
+  ["ENGRAM_", "REMNIC_"]
+];
+function getEnvMap() {
+  const runtimeProcess = globalThis.process;
+  return runtimeProcess?.["env"];
+}
+function legacyEnvCandidates(name) {
+  const candidates = [name];
+  for (const [primary, legacy] of REMNIC_ENGRAM_PREFIX_PAIRS) {
+    if (name.startsWith(primary)) {
+      candidates.push(`${legacy}${name.slice(primary.length)}`);
+    }
+  }
+  return candidates;
+}
+function readEnvVar(name) {
+  const env = getEnvMap();
+  for (const candidate of legacyEnvCandidates(name)) {
+    const value = env?.[candidate];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function resolveHomeDir() {
+  return readEnvVar("HOME") || os.homedir();
+}
+function cloneEnv() {
+  return { ...getEnvMap() ?? {} };
+}
+function mergeEnv(overrides) {
+  const merged = cloneEnv();
+  for (const [key, value] of Object.entries(overrides)) {
+    if (typeof value === "string") merged[key] = value;
+    else delete merged[key];
+  }
+  return merged;
+}
+
+export {
+  readEnvVar,
+  resolveHomeDir,
+  mergeEnv
+};

package/dist/chunk-JZBOXOUC.js

@@ -0,0 +1,259 @@
+import {
+  DEFAULT_ARGON2ID_PARAMS,
+  DEFAULT_SCRYPT_PARAMS,
+  KDF_SALT_LENGTH
+} from "./chunk-6IWEAUN6.js";
+
+// ../remnic-core/src/secure-store/metadata.ts
+var METADATA_FORMAT = "remnic.secure-store.metadata";
+var METADATA_FORMAT_VERSION = 1;
+function bytesToHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function hexToBytes(hex, expectedLength) {
+  if (typeof hex !== "string") {
+    throw new Error("hex field must be a string");
+  }
+  if (!/^[0-9a-f]*$/i.test(hex)) {
+    throw new Error("hex field must contain only hexadecimal characters");
+  }
+  if (hex.length % 2 !== 0) {
+    throw new Error("hex field must have even length");
+  }
+  const buf = Buffer.from(hex, "hex");
+  if (buf.length !== expectedLength) {
+    throw new Error(
+      `hex field decoded to ${buf.length} bytes, expected ${expectedLength}`
+    );
+  }
+  return buf;
+}
+function buildMetadata(options) {
+  const { algorithm, salt } = options;
+  if (!(salt instanceof Uint8Array) || salt.length !== KDF_SALT_LENGTH) {
+    throw new Error(
+      `salt must be ${KDF_SALT_LENGTH} bytes, got ${salt?.length ?? "non-buffer"}`
+    );
+  }
+  const createdAt = options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  let kdf;
+  if (algorithm === "scrypt") {
+    const params = options.params ?? {
+      ...DEFAULT_SCRYPT_PARAMS
+    };
+    kdf = { algorithm: "scrypt", params, salt: bytesToHex(salt) };
+  } else if (algorithm === "argon2id") {
+    const params = options.params ?? {
+      ...DEFAULT_ARGON2ID_PARAMS
+    };
+    kdf = { algorithm: "argon2id", params, salt: bytesToHex(salt) };
+  } else {
+    throw new Error(`unknown KDF algorithm: ${algorithm}`);
+  }
+  const meta = {
+    format: METADATA_FORMAT,
+    formatVersion: METADATA_FORMAT_VERSION,
+    kdf,
+    createdAt
+  };
+  if (options.note !== void 0) {
+    meta.note = options.note;
+  }
+  return meta;
+}
+function serializeMetadata(meta) {
+  validateMetadata(meta);
+  const ordered = {
+    format: meta.format,
+    formatVersion: meta.formatVersion,
+    kdf: orderKdf(meta.kdf),
+    createdAt: meta.createdAt
+  };
+  if (meta.note !== void 0) {
+    ordered.note = meta.note;
+  }
+  return JSON.stringify(ordered, null, 2);
+}
+function orderKdf(kdf) {
+  if (kdf.algorithm === "scrypt") {
+    return {
+      algorithm: kdf.algorithm,
+      params: {
+        N: kdf.params.N,
+        r: kdf.params.r,
+        p: kdf.params.p,
+        keyLength: kdf.params.keyLength,
+        maxmem: kdf.params.maxmem
+      },
+      salt: kdf.salt
+    };
+  }
+  return {
+    algorithm: kdf.algorithm,
+    params: {
+      memoryKiB: kdf.params.memoryKiB,
+      iterations: kdf.params.iterations,
+      parallelism: kdf.params.parallelism,
+      keyLength: kdf.params.keyLength
+    },
+    salt: kdf.salt
+  };
+}
+function parseMetadata(json) {
+  if (typeof json !== "string") {
+    throw new Error("metadata 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(`metadata is not valid JSON: ${msg}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("metadata must be a JSON object");
+  }
+  const obj = parsed;
+  if (obj.format !== METADATA_FORMAT) {
+    throw new Error(
+      `unexpected metadata format: ${String(obj.format)} (expected ${METADATA_FORMAT})`
+    );
+  }
+  if (obj.formatVersion !== METADATA_FORMAT_VERSION) {
+    throw new Error(
+      `unsupported metadata formatVersion: ${String(obj.formatVersion)} (this build supports ${METADATA_FORMAT_VERSION})`
+    );
+  }
+  if (typeof obj.createdAt !== "string" || obj.createdAt.length === 0) {
+    throw new Error("metadata.createdAt must be a non-empty string");
+  }
+  if (obj.note !== void 0 && typeof obj.note !== "string") {
+    throw new Error("metadata.note must be a string when present");
+  }
+  const kdf = parseKdf(obj.kdf);
+  const meta = {
+    format: METADATA_FORMAT,
+    formatVersion: METADATA_FORMAT_VERSION,
+    kdf,
+    createdAt: obj.createdAt
+  };
+  if (typeof obj.note === "string") {
+    meta.note = obj.note;
+  }
+  validateMetadata(meta);
+  return meta;
+}
+function parseKdf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("metadata.kdf must be an object");
+  }
+  const k = value;
+  if (k.algorithm !== "scrypt" && k.algorithm !== "argon2id") {
+    throw new Error(`metadata.kdf.algorithm must be 'scrypt' or 'argon2id', got ${String(k.algorithm)}`);
+  }
+  if (typeof k.salt !== "string") {
+    throw new Error("metadata.kdf.salt must be a hex string");
+  }
+  hexToBytes(k.salt, KDF_SALT_LENGTH);
+  if (typeof k.params !== "object" || k.params === null || Array.isArray(k.params)) {
+    throw new Error("metadata.kdf.params must be an object");
+  }
+  const params = k.params;
+  if (k.algorithm === "scrypt") {
+    const required = ["N", "r", "p", "keyLength", "maxmem"];
+    for (const key of required) {
+      if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
+        throw new Error(`metadata.kdf.params.${key} must be a finite number`);
+      }
+    }
+    return {
+      algorithm: "scrypt",
+      params: {
+        N: params.N,
+        r: params.r,
+        p: params.p,
+        keyLength: params.keyLength,
+        maxmem: params.maxmem
+      },
+      salt: k.salt
+    };
+  }
+  const required2 = [
+    "memoryKiB",
+    "iterations",
+    "parallelism",
+    "keyLength"
+  ];
+  for (const key of required2) {
+    if (typeof params[key] !== "number" || !Number.isFinite(params[key])) {
+      throw new Error(`metadata.kdf.params.${key} must be a finite number`);
+    }
+  }
+  return {
+    algorithm: "argon2id",
+    params: {
+      memoryKiB: params.memoryKiB,
+      iterations: params.iterations,
+      parallelism: params.parallelism,
+      keyLength: params.keyLength
+    },
+    salt: k.salt
+  };
+}
+function validateMetadata(meta) {
+  if (meta.format !== METADATA_FORMAT) {
+    throw new Error(`metadata.format must be ${METADATA_FORMAT}`);
+  }
+  if (meta.formatVersion !== METADATA_FORMAT_VERSION) {
+    throw new Error(`metadata.formatVersion must be ${METADATA_FORMAT_VERSION}`);
+  }
+  if (typeof meta.createdAt !== "string" || meta.createdAt.length === 0) {
+    throw new Error("metadata.createdAt must be a non-empty ISO-8601 string");
+  }
+  hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
+  if (meta.kdf.algorithm === "scrypt") {
+    const { N, r, p, keyLength, maxmem } = meta.kdf.params;
+    if (!Number.isInteger(N) || N < 2 || N > 2 ** 30 || !Number.isInteger(Math.log2(N))) {
+      throw new Error("metadata.kdf.params.N must be a power of 2 in [2, 2^30]");
+    }
+    if (!Number.isInteger(r) || r < 1) {
+      throw new Error("metadata.kdf.params.r must be a positive integer");
+    }
+    if (!Number.isInteger(p) || p < 1) {
+      throw new Error("metadata.kdf.params.p must be a positive integer");
+    }
+    if (!Number.isInteger(keyLength) || keyLength !== 32) {
+      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
+    }
+    if (!Number.isInteger(maxmem) || maxmem < 1024) {
+      throw new Error("metadata.kdf.params.maxmem must be a positive integer");
+    }
+  } else if (meta.kdf.algorithm === "argon2id") {
+    const { memoryKiB, iterations, parallelism, keyLength } = meta.kdf.params;
+    if (!Number.isInteger(memoryKiB) || memoryKiB < 8) {
+      throw new Error("metadata.kdf.params.memoryKiB must be \u2265 8");
+    }
+    if (!Number.isInteger(iterations) || iterations < 1) {
+      throw new Error("metadata.kdf.params.iterations must be a positive integer");
+    }
+    if (!Number.isInteger(parallelism) || parallelism < 1 || parallelism > 255) {
+      throw new Error("metadata.kdf.params.parallelism must be an integer in [1, 255]");
+    }
+    if (!Number.isInteger(keyLength) || keyLength !== 32) {
+      throw new Error("metadata.kdf.params.keyLength must be 32 (AES-256 requires a 32-byte key)");
+    }
+  }
+}
+function decodeMetadataSalt(meta) {
+  return hexToBytes(meta.kdf.salt, KDF_SALT_LENGTH);
+}
+
+export {
+  METADATA_FORMAT,
+  METADATA_FORMAT_VERSION,
+  buildMetadata,
+  serializeMetadata,
+  parseMetadata,
+  validateMetadata,
+  decodeMetadataSalt
+};

package/dist/chunk-K7EUBNDD.js

@@ -0,0 +1,185 @@
+import {
+  external_exports
+} from "./chunk-XMSDA5WA.js";
+
+// ../remnic-core/src/transfer/types.ts
+var ExportManifestV1Schema = external_exports.object({
+  format: external_exports.literal("openclaw-engram-export"),
+  schemaVersion: external_exports.literal(1),
+  createdAt: external_exports.string(),
+  pluginVersion: external_exports.string(),
+  includesTranscripts: external_exports.boolean(),
+  files: external_exports.array(
+    external_exports.object({
+      path: external_exports.string(),
+      sha256: external_exports.string(),
+      bytes: external_exports.number().int().nonnegative()
+    })
+  )
+});
+var ExportMemoryRecordV1Schema = external_exports.object({
+  path: external_exports.string(),
+  content: external_exports.string()
+});
+var ExportBundleV1Schema = external_exports.object({
+  manifest: ExportManifestV1Schema,
+  records: external_exports.array(ExportMemoryRecordV1Schema)
+});
+var CAPSULE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?!-))*[A-Za-z0-9]$|^[A-Za-z0-9]$/;
+var CapsuleIdSchema = external_exports.string().min(1, "capsule.id must not be empty").max(64, "capsule.id must be 64 characters or fewer").regex(
+  CAPSULE_ID_PATTERN,
+  "capsule.id must be alphanumeric with single dashes (no spaces, no leading/trailing dashes)"
+);
+var SemverLikeSchema = external_exports.string().min(1, "capsule.version must not be empty").regex(
+  /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/,
+  "capsule.version must be a semver-like string (e.g. 1.0.0)"
+);
+var CapsuleRetrievalPolicySchema = external_exports.object({
+  /**
+   * Per-tier weight overrides applied during recall when the capsule is the
+   * active scope. Keys are tier names (e.g. `bm25`, `vector`, `graph`); values
+   * are non-negative finite multipliers. The set of valid keys is left open
+   * for now so future tiers do not break older manifests.
+   */
+  tierWeights: external_exports.record(
+    external_exports.string().min(1),
+    external_exports.number().finite().nonnegative()
+  ),
+  /**
+   * Whether the direct-answer fast path is allowed when this capsule is
+   * active. Operators may disable it for capsules whose contents should
+   * always flow through the full retrieval pipeline.
+   */
+  directAnswerEnabled: external_exports.boolean()
+});
+var CapsuleIncludesSchema = external_exports.object({
+  taxonomy: external_exports.boolean(),
+  identityAnchors: external_exports.boolean(),
+  peerProfiles: external_exports.boolean(),
+  procedural: external_exports.boolean()
+});
+var CapsuleParentSchema = external_exports.object({
+  capsuleId: CapsuleIdSchema,
+  version: SemverLikeSchema,
+  /**
+   * Posix-relative path prefix under the fork's memory root where the parent
+   * capsule's records were placed. Typically `forks/<parent-capsule-id>`.
+   * Must be a non-empty string with no leading slash.
+   */
+  forkRoot: external_exports.string().min(1, "capsule.parent.forkRoot must not be empty").refine((v) => !v.startsWith("/"), {
+    message: "capsule.parent.forkRoot must be a relative path (no leading slash)"
+  })
+});
+var CapsuleBlockSchema = external_exports.object({
+  id: CapsuleIdSchema,
+  version: SemverLikeSchema,
+  /**
+   * Taxonomy schema version the capsule was authored against. Free-form for
+   * now; later PRs may tighten this to a known taxonomy registry.
+   */
+  schemaVersion: external_exports.string().min(1, "capsule.schemaVersion must not be empty"),
+  /**
+   * Optional reference to the parent capsule this one was forked or derived
+   * from. `null` (not `undefined`) is the explicit "no parent" sentinel so
+   * that round-trips through JSON do not silently drop the field.
+   *
+   * @deprecated Prefer {@link parent} (structured). This field is preserved
+   *   for backward compatibility with V2 manifests written before PR 4/6.
+   */
+  parentCapsule: external_exports.string().min(1).nullable(),
+  /**
+   * Structured fork-lineage pointer added in PR 4/6. When present, this
+   * capsule is a fork of the described parent. `null` is the explicit
+   * "not a fork" sentinel — round-trips through JSON cleanly without
+   * silently dropping the field.
+   *
+   * Defaults to `null` so that V2 manifests written before PR 4/6 (which
+   * omit this field) still parse without error. This preserves backward
+   * compatibility with the existing `makeV2Manifest()` test fixtures and
+   * any in-the-wild V2 archives produced by PR 2/6 and PR 3/6.
+   *
+   * Invariant: when `parent` is non-null, `parentCapsule` SHOULD equal
+   * `parent.capsuleId` for backward compatibility with readers that only
+   * understand the legacy field. `forkCapsule()` sets both.
+   */
+  parent: CapsuleParentSchema.nullable().default(null),
+  description: external_exports.string(),
+  retrievalPolicy: CapsuleRetrievalPolicySchema,
+  includes: CapsuleIncludesSchema
+});
+var ExportManifestV2Schema = external_exports.object({
+  format: external_exports.literal("openclaw-engram-export"),
+  schemaVersion: external_exports.literal(2),
+  createdAt: external_exports.string(),
+  pluginVersion: external_exports.string(),
+  includesTranscripts: external_exports.boolean(),
+  files: external_exports.array(
+    external_exports.object({
+      path: external_exports.string(),
+      sha256: external_exports.string(),
+      bytes: external_exports.number().int().nonnegative()
+    })
+  ),
+  capsule: CapsuleBlockSchema
+});
+var ExportBundleV2Schema = external_exports.object({
+  manifest: ExportManifestV2Schema,
+  records: external_exports.array(ExportMemoryRecordV1Schema)
+});
+function parseExportManifest(input) {
+  const version = typeof input === "object" && input !== null ? input.schemaVersion : void 0;
+  if (version === 2) {
+    const manifest = ExportManifestV2Schema.parse(input);
+    return {
+      capsuleVersion: 2,
+      manifest,
+      capsule: manifest.capsule
+    };
+  }
+  if (version === 1) {
+    const manifest = ExportManifestV1Schema.parse(input);
+    return { capsuleVersion: 1, manifest, capsule: null };
+  }
+  const v1 = ExportManifestV1Schema.safeParse(input);
+  if (v1.success) {
+    return { capsuleVersion: 1, manifest: v1.data, capsule: null };
+  }
+  const v2 = ExportManifestV2Schema.safeParse(input);
+  if (v2.success) {
+    return {
+      capsuleVersion: 2,
+      manifest: v2.data,
+      capsule: v2.data.capsule
+    };
+  }
+  throw v2.error;
+}
+function parseExportBundle(input) {
+  if (typeof input !== "object" || input === null) {
+    ExportBundleV1Schema.parse(input);
+    throw new Error("unreachable");
+  }
+  const manifestRaw = input.manifest;
+  const normalized = parseExportManifest(manifestRaw);
+  if (normalized.capsuleVersion === 2) {
+    const bundle2 = ExportBundleV2Schema.parse(input);
+    return { capsuleVersion: 2, bundle: bundle2, capsule: bundle2.manifest.capsule };
+  }
+  const bundle = ExportBundleV1Schema.parse(input);
+  return { capsuleVersion: 1, bundle, capsule: null };
+}
+
+export {
+  ExportManifestV1Schema,
+  ExportMemoryRecordV1Schema,
+  ExportBundleV1Schema,
+  CAPSULE_ID_PATTERN,
+  CapsuleRetrievalPolicySchema,
+  CapsuleIncludesSchema,
+  CapsuleParentSchema,
+  CapsuleBlockSchema,
+  ExportManifestV2Schema,
+  ExportBundleV2Schema,
+  parseExportManifest,
+  parseExportBundle
+};