@remnic/plugin-openclaw 1.0.10 → 1.0.12

package/dist/chunk-L6I4MQKO.js

@@ -0,0 +1,227 @@
+import {
+  parseExportBundle
+} from "./chunk-4LYQ4ONL.js";
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  sha256String
+} from "./chunk-NKVIN6RD.js";
+import {
+  decryptCapsuleFileInMemory,
+  isEncryptedCapsuleFile
+} from "./chunk-SSFTU6LP.js";
+import {
+  createVersion
+} from "./chunk-6OJAU466.js";
+
+// ../remnic-core/src/transfer/capsule-import.ts
+import { lstat, mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+import { gunzipSync } from "zlib";
+async function importCapsule(opts) {
+  const archiveAbs = path.resolve(opts.archivePath);
+  const rootAbs = path.resolve(opts.root);
+  await assertIsDirectoryNotSymlink(rootAbs, "importCapsule", "root");
+  const mode = opts.mode ?? "skip";
+  if (mode !== "skip" && mode !== "overwrite" && mode !== "fork") {
+    throw new Error(
+      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected "skip", "overwrite", or "fork"`
+    );
+  }
+  const encrypted = await isEncryptedCapsuleFile(archiveAbs);
+  let raw;
+  if (encrypted) {
+    if (!opts.memoryDir) {
+      throw new Error(
+        `importCapsule: archive is encrypted but 'memoryDir' was not provided. Pass the memory directory so the secure-store key can be retrieved, or run \`remnic secure-store unlock\` before importing.`
+      );
+    }
+    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir);
+  } else {
+    raw = await readFile(archiveAbs);
+  }
+  const json = gunzipSync(raw).toString("utf-8");
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(json);
+  } catch (cause) {
+    throw new Error(
+      `importCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,
+      { cause }
+    );
+  }
+  const parsed = parseExportBundle(parsedJson);
+  if (parsed.capsuleVersion !== 2) {
+    throw new Error(
+      "importCapsule: 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(
+      "importCapsule: manifest contains duplicate file paths"
+    );
+  }
+  const recordPaths = /* @__PURE__ */ new Set();
+  for (const rec of bundle.records) {
+    if (recordPaths.has(rec.path)) {
+      throw new Error(
+        `importCapsule: 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(
+        `importCapsule: 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(
+        `importCapsule: 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(
+        `importCapsule: 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(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    if (!isPathInsideRoot(rootReal, targetAbs)) {
+      throw new Error(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, "importCapsule");
+    const targetLstat = await lstat(targetAbs).catch(() => null);
+    if (targetLstat !== null && targetLstat.isSymbolicLink()) {
+      throw new Error(
+        `importCapsule: 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(
+        `importCapsule: manifest contains two entries that resolve to the same target path: "${firstSourcePath}" and "${rec.path}" both map to "${targetRel}"`
+      );
+    }
+    seenTargetPaths.set(dedupKey, rec.path);
+  }
+  for (const f of manifest.files) {
+    if (!recordPaths.has(f.path)) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`
+      );
+    }
+  }
+  const imported = [];
+  const skipped = [];
+  const sortedRecords = [...bundle.records].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  for (const rec of sortedRecords) {
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    const exists = await fileExistsAt(targetAbs);
+    if ((mode === "skip" || mode === "fork") && exists) {
+      skipped.push({ path: rec.path, reason: "exists" });
+      continue;
+    }
+    let snapshotted = false;
+    if (mode === "overwrite" && exists) {
+      if (opts.versioning && opts.versioning.enabled) {
+        const prior = await readFile(targetAbs, "utf-8").catch(() => "");
+        await createVersion(
+          targetAbs,
+          prior,
+          "manual",
+          opts.versioning,
+          opts.log,
+          `capsule-import: ${capsule.id}`,
+          rootReal
+        );
+        snapshotted = true;
+      }
+    }
+    let contentToWrite = rec.content;
+    let rewroteId = false;
+    if (mode === "fork") {
+      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);
+      contentToWrite = forked.content;
+      rewroteId = forked.rewrote;
+    }
+    await mkdir(path.dirname(targetAbs), { recursive: true });
+    await writeFile(targetAbs, contentToWrite, "utf-8");
+    imported.push({
+      sourcePath: rec.path,
+      targetPath: targetRel,
+      snapshotted,
+      rewroteId
+    });
+  }
+  skipped.sort((a, b) => a.path.localeCompare(b.path));
+  return { imported, skipped, manifest };
+}
+function computeTargetPath(sourcePosix, mode, capsuleId) {
+  if (mode === "fork") return `forks/${capsuleId}/${sourcePosix}`;
+  return sourcePosix;
+}
+async function fileExistsAt(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  return st !== null && st.isFile();
+}
+function rewriteFrontmatterIdForFork(content, capsuleId, now) {
+  const crlfMatch = /^---(\r\n|\r|\n)/.exec(content);
+  const eol = crlfMatch ? crlfMatch[1] : "\n";
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/.exec(content);
+  if (!fmMatch) return { content, rewrote: false };
+  const fmBody = fmMatch[1];
+  const fmTrailer = fmMatch[2];
+  const fmStart = fmMatch.index;
+  const fmEnd = fmStart + fmMatch[0].length;
+  const idLineRe = /^id:[ \t]*([^\r\n]*)$/m;
+  const idMatch = idLineRe.exec(fmBody);
+  if (!idMatch) return { content, rewrote: false };
+  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? "", now);
+  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);
+  const prefix = content.slice(0, fmStart);
+  const tail = content.slice(fmEnd);
+  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;
+  return { content: rebuilt, rewrote: true };
+}
+function mintForkId(capsuleId, originalId, now) {
+  const base = originalId.length > 0 ? originalId : "fork";
+  if (now === void 0) {
+    const suffix2 = randomUUID().slice(0, 8);
+    return `${base}-fork-${capsuleId}-${suffix2}`;
+  }
+  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });
+  const suffix = createHash("sha256").update(payload, "utf-8").digest("hex").slice(0, 8);
+  return `${base}-fork-${capsuleId}-${suffix}`;
+}
+
+export {
+  importCapsule
+};

package/dist/chunk-LLUROTZJ.js

@@ -0,0 +1,328 @@
+// ../remnic-core/src/capsule-cli.ts
+import path from "path";
+function parseCapsuleOutputFormat(raw) {
+  if (raw === void 0 || raw === null) return "text";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--format expects one of text, markdown, json; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "text" && v !== "markdown" && v !== "json") {
+    throw new Error(
+      `--format expects one of text, markdown, json; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+function parseCapsuleImportMode(raw) {
+  if (raw === void 0 || raw === null) return "skip";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--mode expects one of skip, overwrite, fork; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "skip" && v !== "overwrite" && v !== "fork") {
+    throw new Error(
+      `--mode expects one of skip, overwrite, fork; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+function parseCapsuleConflictMode(raw) {
+  if (raw === void 0 || raw === null) return "skip-conflicts";
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(
+      `--conflict-mode expects one of skip-conflicts, prefer-source, prefer-local; got ${JSON.stringify(raw)}`
+    );
+  }
+  const v = raw.trim();
+  if (v !== "skip-conflicts" && v !== "prefer-source" && v !== "prefer-local") {
+    throw new Error(
+      `--conflict-mode expects one of skip-conflicts, prefer-source, prefer-local; got ${JSON.stringify(raw)}`
+    );
+  }
+  return v;
+}
+var ISO_8601_RE = /^\d{4}-\d{2}-\d{2}(?:[Tt]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:[Zz]|[+-]\d{2}:?\d{2}))?$/;
+function parseCapsuleSince(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--since expects an ISO 8601 timestamp; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(`--since expects an ISO 8601 timestamp; received empty string`);
+  }
+  if (!ISO_8601_RE.test(raw)) {
+    throw new Error(
+      `--since is not a valid ISO 8601 timestamp: ${raw}. Accepted forms: YYYY-MM-DD, YYYY-MM-DDTHH:MM:SSZ, YYYY-MM-DDTHH:MM:SS\xB1HH:MM`
+    );
+  }
+  const ms = Date.parse(raw);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`--since is not a valid ISO 8601 timestamp: ${raw}`);
+  }
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(raw);
+  if (m) {
+    const offsetMatch = /([+-])(\d{2}):?(\d{2})$/.exec(raw);
+    let displayMs = ms;
+    if (offsetMatch) {
+      const sign = offsetMatch[1] === "-" ? -1 : 1;
+      const offsetMin = sign * (Number(offsetMatch[2]) * 60 + Number(offsetMatch[3]));
+      displayMs = ms + offsetMin * 6e4;
+    }
+    const dd = new Date(displayMs);
+    if (dd.getUTCFullYear() !== Number(m[1]) || dd.getUTCMonth() + 1 !== Number(m[2]) || dd.getUTCDate() !== Number(m[3])) {
+      throw new Error(
+        `--since: calendar overflow \u2014 ${raw} normalises to a different calendar date`
+      );
+    }
+  }
+  return raw;
+}
+function parseCapsuleIncludeKinds(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--include-kinds expects a comma-separated list of directory names; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(
+      `--include-kinds expects at least one non-empty kind name`
+    );
+  }
+  const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (parts.length === 0) {
+    throw new Error(`--include-kinds expects at least one non-empty kind name`);
+  }
+  for (const p of parts) {
+    if (p.includes("/") || p.includes("\\")) {
+      throw new Error(
+        `--include-kinds entries must be top-level directory names (no path separators): ${p}`
+      );
+    }
+  }
+  return [...new Set(parts)];
+}
+function parseCapsulePeers(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error(
+      `--peers expects a comma-separated list of peer ids; got ${JSON.stringify(raw)}`
+    );
+  }
+  if (raw.trim() === "") {
+    throw new Error(`--peers expects at least one non-empty peer id`);
+  }
+  const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (parts.length === 0) {
+    throw new Error(`--peers expects at least one non-empty peer id`);
+  }
+  for (const p of parts) {
+    if (p.includes("/") || p.includes("\\") || p === "." || p === "..") {
+      throw new Error(
+        `--peers entries must be plain id tokens (no path separators): ${p}`
+      );
+    }
+  }
+  return [...new Set(parts)];
+}
+function parseCapsuleExportOptions(nameArg, opts) {
+  if (typeof nameArg !== "string" || nameArg.trim() === "") {
+    throw new Error(
+      `capsule export: <name> is required (e.g. "remnic capsule export my-capsule")`
+    );
+  }
+  const name = nameArg.trim();
+  const out = typeof opts.out === "string" && opts.out.trim() !== "" ? opts.out.trim() : void 0;
+  const since = parseCapsuleSince(opts.since);
+  const includeKinds = parseCapsuleIncludeKinds(opts.includeKinds);
+  const peers = parseCapsulePeers(opts.peers);
+  return { name, out, since, includeKinds, peers };
+}
+function parseCapsuleImportOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule import: <archive> path is required (e.g. "remnic capsule import /path/to/my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const mode = parseCapsuleImportMode(opts.mode);
+  return { archive, mode };
+}
+function parseCapsuleMergeOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule merge: <archive> path is required (e.g. "remnic capsule merge /path/to/my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const conflictMode = parseCapsuleConflictMode(opts.conflictMode);
+  return { archive, conflictMode };
+}
+function parseCapsuleListOptions(opts, defaultCapsulesDir2) {
+  const format = parseCapsuleOutputFormat(opts.format);
+  const rawDir = typeof opts.dir === "string" && opts.dir.trim() !== "" ? opts.dir.trim() : void 0;
+  const capsulesDir = rawDir ?? defaultCapsulesDir2;
+  return { format, capsulesDir };
+}
+function parseCapsuleInspectOptions(archiveArg, opts) {
+  if (typeof archiveArg !== "string" || archiveArg.trim() === "") {
+    throw new Error(
+      `capsule inspect: <archive> path is required (e.g. "remnic capsule inspect my-capsule.capsule.json.gz")`
+    );
+  }
+  const archive = archiveArg.trim();
+  const format = parseCapsuleOutputFormat(opts.format);
+  return { archive, format };
+}
+function defaultCapsulesDir(memoryDir) {
+  return path.join(memoryDir, ".capsules");
+}
+function escapeMarkdownCell(v) {
+  return v.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+}
+function renderCapsuleList(entries, format) {
+  if (format === "json") {
+    return JSON.stringify({ capsules: entries }, null, 2);
+  }
+  if (entries.length === 0) {
+    if (format === "markdown") return "_No capsule archives found._\n";
+    return "No capsule archives found.\n";
+  }
+  if (format === "markdown") {
+    const rows = entries.map((e) => {
+      const id = escapeMarkdownCell(e.id);
+      const date = escapeMarkdownCell(e.createdAt?.slice(0, 10) ?? "\u2014");
+      const ver = escapeMarkdownCell(e.pluginVersion ?? "\u2014");
+      const files = e.fileCount !== null ? String(e.fileCount) : "\u2014";
+      const desc = escapeMarkdownCell(
+        e.description != null && e.description.trim() !== "" ? e.description.trim() : "\u2014"
+      );
+      return `| \`${id}\` | ${date} | ${ver} | ${files} | ${desc} |`;
+    });
+    return [
+      "# Capsule archives",
+      "",
+      "| ID | Created | Version | Files | Description |",
+      "| -- | ------- | ------- | ----- | ----------- |",
+      ...rows,
+      ""
+    ].join("\n");
+  }
+  const lines = entries.map((e) => {
+    const date = e.createdAt?.slice(0, 10) ?? "\u2014";
+    const files = e.fileCount !== null ? `${e.fileCount} file${e.fileCount !== 1 ? "s" : ""}` : "? files";
+    const desc = e.description != null && e.description.trim() !== "" ? `  ${e.description.trim()}` : "";
+    return `${e.id}  [${date}] [${files}]${desc}`;
+  });
+  return lines.join("\n") + "\n";
+}
+function renderCapsuleInspect(manifest, format) {
+  if (format === "json") {
+    return JSON.stringify(manifest, null, 2);
+  }
+  const {
+    capsuleId,
+    version,
+    schemaVersion,
+    createdAt,
+    pluginVersion,
+    fileCount,
+    includesTranscripts,
+    description,
+    parentCapsule,
+    retrievalPolicy,
+    includes,
+    topFiles
+  } = manifest;
+  if (format === "markdown") {
+    const policyLines = Object.entries(retrievalPolicy.tierWeights ?? {}).map(
+      ([k, v]) => `  - ${k}: ${v}`
+    );
+    const policyBlock = policyLines.length > 0 ? policyLines.join("\n") : "  _(no tier weight overrides)_";
+    return [
+      `# Capsule: \`${capsuleId}\``,
+      "",
+      `**Version:** ${version}  `,
+      `**Schema version:** ${schemaVersion}  `,
+      `**Created:** ${createdAt ?? "\u2014"}  `,
+      `**Plugin version:** ${pluginVersion ?? "\u2014"}  `,
+      `**Files:** ${fileCount}  `,
+      `**Includes transcripts:** ${includesTranscripts ? "yes" : "no"}  `,
+      `**Parent capsule:** ${parentCapsule ?? "_none_"}  `,
+      `**Description:** ${description && description.trim() !== "" ? description.trim() : "_none_"}  `,
+      "",
+      "## Includes",
+      `- taxonomy: ${includes.taxonomy ? "yes" : "no"}`,
+      `- identityAnchors: ${includes.identityAnchors ? "yes" : "no"}`,
+      `- peerProfiles: ${includes.peerProfiles ? "yes" : "no"}`,
+      `- procedural: ${includes.procedural ? "yes" : "no"}`,
+      "",
+      "## Retrieval policy",
+      `- directAnswerEnabled: ${retrievalPolicy.directAnswerEnabled ? "yes" : "no"}`,
+      `- tierWeights:`,
+      policyBlock,
+      "",
+      ...topFiles.length > 0 ? [
+        `## Files (${fileCount} total, showing first ${topFiles.length})`,
+        ...topFiles.map((f) => `- \`${f}\``),
+        ""
+      ] : [`## Files (${fileCount} total)`, "_Empty capsule._", ""]
+    ].join("\n");
+  }
+  const lines = [
+    `Capsule: ${capsuleId}`,
+    `  version:          ${version}`,
+    `  schema:           ${schemaVersion}`,
+    `  created:          ${createdAt ?? "\u2014"}`,
+    `  plugin:           ${pluginVersion ?? "\u2014"}`,
+    `  files:            ${fileCount}`,
+    `  transcripts:      ${includesTranscripts ? "yes" : "no"}`,
+    `  parent:           ${parentCapsule ?? "(none)"}`,
+    `  description:      ${description && description.trim() !== "" ? description.trim() : "(none)"}`,
+    "",
+    `  includes.taxonomy:        ${includes.taxonomy ? "yes" : "no"}`,
+    `  includes.identityAnchors: ${includes.identityAnchors ? "yes" : "no"}`,
+    `  includes.peerProfiles:    ${includes.peerProfiles ? "yes" : "no"}`,
+    `  includes.procedural:      ${includes.procedural ? "yes" : "no"}`,
+    "",
+    `  policy.directAnswer:   ${retrievalPolicy.directAnswerEnabled ? "yes" : "no"}`
+  ];
+  const weights = Object.entries(retrievalPolicy.tierWeights ?? {});
+  if (weights.length > 0) {
+    for (const [k, v] of weights) {
+      lines.push(`  policy.tierWeight[${k}]: ${v}`);
+    }
+  } else {
+    lines.push(`  policy.tierWeights:    (none)`);
+  }
+  if (topFiles.length > 0) {
+    lines.push("", `  files (first ${topFiles.length} of ${fileCount}):`);
+    for (const f of topFiles) {
+      lines.push(`    ${f}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+export {
+  parseCapsuleOutputFormat,
+  parseCapsuleImportMode,
+  parseCapsuleConflictMode,
+  parseCapsuleSince,
+  parseCapsuleIncludeKinds,
+  parseCapsulePeers,
+  parseCapsuleExportOptions,
+  parseCapsuleImportOptions,
+  parseCapsuleMergeOptions,
+  parseCapsuleListOptions,
+  parseCapsuleInspectOptions,
+  defaultCapsulesDir,
+  renderCapsuleList,
+  renderCapsuleInspect
+};