@jheavenknows/bluerouter 5.2.77 → 5.2.78

package/app/open-sse/utils/localPromptCas.js

@@ -1,256 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import zlib from "node:zlib";
-
-const FORMAT = "bluerouter-semantic-cas-v1";
-const MARKER = "$blueRouterLocalLog";
-const CAS_DIR_NAME = "request-cas-v1";
-const OBJECT_EXT = ".json.br";
-const SEMANTIC_ARRAY_KINDS = new Map([
-  ["system", "system"],
-  ["tools", "tool"],
-  ["messages", "message"],
-  ["contents", "message"],
-]);
-
-function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function normalizeJsonValue(value, inArray = false) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      if (item === undefined || typeof item === "function" || typeof item === "symbol") return null;
-      return normalizeJsonValue(item, true);
-    });
-  }
-  if (isObject(value)) {
-    const out = {};
-    for (const key of Object.keys(value).sort()) {
-      const item = value[key];
-      if (item === undefined || typeof item === "function" || typeof item === "symbol") continue;
-      out[key] = normalizeJsonValue(item, false);
-    }
-    return out;
-  }
-  if (inArray) return null;
-  return String(value);
-}
-
-function stableStringify(value) {
-  return JSON.stringify(normalizeJsonValue(value));
-}
-
-function objectHash(kind, value) {
-  const canonical = stableStringify({ kind, value });
-  return {
-    hash: crypto.createHash("sha256").update(canonical, "utf8").digest("hex"),
-    canonical,
-  };
-}
-
-function getCasRoot(sessionPath) {
-  const requestLogsDir = path.dirname(sessionPath);
-  return path.join(path.dirname(requestLogsDir), CAS_DIR_NAME);
-}
-
-function objectPath(casRoot, hash) {
-  return path.join(casRoot, "objects", hash.slice(0, 2), hash.slice(2, 4), `${hash}${OBJECT_EXT}`);
-}
-
-function atomicWrite(filePath, bytes) {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-  if (fs.existsSync(filePath)) return false;
-
-  const temp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`);
-  let fd = null;
-  try {
-    fd = fs.openSync(temp, "wx", 0o640);
-    fs.writeFileSync(fd, bytes);
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    fd = null;
-
-    try {
-      fs.renameSync(temp, filePath);
-      return true;
-    } catch (err) {
-      // Another request may have won the race for the same content hash.
-      if (fs.existsSync(filePath)) return false;
-      throw err;
-    }
-  } finally {
-    if (fd !== null) {
-      try { fs.closeSync(fd); } catch { /* ignore */ }
-    }
-    try { if (fs.existsSync(temp)) fs.unlinkSync(temp); } catch { /* ignore */ }
-  }
-}
-
-function writeObject(casRoot, kind, value, stats) {
-  const { hash, canonical } = objectHash(kind, value);
-  const filePath = objectPath(casRoot, hash);
-  const rawBytes = Buffer.byteLength(canonical, "utf8");
-
-  if (fs.existsSync(filePath)) {
-    stats.reusedObjects += 1;
-    stats.reusedRawBytes += rawBytes;
-    return hash;
-  }
-
-  const compressed = zlib.brotliCompressSync(Buffer.from(canonical, "utf8"), {
-    params: {
-      [zlib.constants.BROTLI_PARAM_QUALITY]: 4,
-    },
-  });
-  const created = atomicWrite(filePath, compressed);
-  if (created) {
-    stats.newObjects += 1;
-    stats.newRawBytes += rawBytes;
-    stats.newStoredBytes += compressed.length;
-  } else {
-    stats.reusedObjects += 1;
-    stats.reusedRawBytes += rawBytes;
-  }
-  return hash;
-}
-
-function encodeBodyNode(value, casRoot, stats, keyHint = "") {
-  if (Array.isArray(value)) {
-    const semanticKind = SEMANTIC_ARRAY_KINDS.get(keyHint);
-    if (semanticKind) {
-      return {
-        $casArray: semanticKind,
-        refs: value.map((item) => writeObject(casRoot, semanticKind, item, stats)),
-      };
-    }
-    return value.map((item) => encodeBodyNode(item, casRoot, stats, ""));
-  }
-
-  if (isObject(value)) {
-    const out = {};
-    for (const [key, item] of Object.entries(value)) {
-      out[key] = encodeBodyNode(item, casRoot, stats, key);
-    }
-    return out;
-  }
-
-  return value;
-}
-
-function readObject(casRoot, hash, expectedKind = null) {
-  if (!/^[0-9a-f]{64}$/.test(String(hash || ""))) {
-    throw new Error(`Invalid CAS hash: ${hash}`);
-  }
-  const filePath = objectPath(casRoot, hash);
-  const compressed = fs.readFileSync(filePath);
-  const canonical = zlib.brotliDecompressSync(compressed).toString("utf8");
-  const parsed = JSON.parse(canonical);
-  if (!parsed || typeof parsed !== "object" || typeof parsed.kind !== "string" || !("value" in parsed)) {
-    throw new Error(`Invalid CAS object: ${hash}`);
-  }
-  if (expectedKind && parsed.kind !== expectedKind) {
-    throw new Error(`CAS kind mismatch for ${hash}: expected ${expectedKind}, got ${parsed.kind}`);
-  }
-  const actual = crypto.createHash("sha256").update(canonical, "utf8").digest("hex");
-  if (actual !== hash) {
-    throw new Error(`CAS integrity check failed for ${hash}`);
-  }
-  return parsed.value;
-}
-
-function decodeBodyNode(value, casRoot) {
-  if (Array.isArray(value)) return value.map((item) => decodeBodyNode(item, casRoot));
-  if (!isObject(value)) return value;
-
-  if (typeof value.$casArray === "string" && Array.isArray(value.refs)) {
-    return value.refs.map((hash) => readObject(casRoot, hash, value.$casArray));
-  }
-
-  const out = {};
-  for (const [key, item] of Object.entries(value)) {
-    out[key] = decodeBodyNode(item, casRoot);
-  }
-  return out;
-}
-
-function writeManifestAtomic(filePath, manifest) {
-  const bytes = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-  const dir = path.dirname(filePath);
-  const temp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`);
-  let fd = null;
-  try {
-    fd = fs.openSync(temp, "wx", 0o640);
-    fs.writeFileSync(fd, bytes);
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    fd = null;
-    fs.renameSync(temp, filePath);
-  } finally {
-    if (fd !== null) {
-      try { fs.closeSync(fd); } catch { /* ignore */ }
-    }
-    try { if (fs.existsSync(temp)) fs.unlinkSync(temp); } catch { /* ignore */ }
-  }
-}
-
-export function isDedupRequestManifest(value) {
-  return Boolean(value && value[MARKER] === 1 && value.format === FORMAT && value.bodyRef);
-}
-
-export function convertPlainRequestFileToCas(sessionPath, filename) {
-  const filePath = path.join(sessionPath, filename);
-  if (!fs.existsSync(filePath)) return null;
-
-  const originalText = fs.readFileSync(filePath, "utf8");
-  const original = JSON.parse(originalText);
-  if (isDedupRequestManifest(original)) return original;
-  // Preserve the existing redacted-file behavior; there is nothing useful to dedupe.
-  if (original?.contentRedacted === true) return original;
-  if (!Object.prototype.hasOwnProperty.call(original || {}, "body")) return original;
-
-  const casRoot = getCasRoot(sessionPath);
-  const stats = {
-    logicalBytes: Buffer.byteLength(originalText, "utf8"),
-    newObjects: 0,
-    reusedObjects: 0,
-    newRawBytes: 0,
-    reusedRawBytes: 0,
-    newStoredBytes: 0,
-  };
-
-  const encodedBody = encodeBodyNode(original.body, casRoot, stats, "body");
-  const bodyRef = writeObject(casRoot, "body_manifest", encodedBody, stats);
-  const wrapper = { ...original };
-  delete wrapper.body;
-
-  const manifest = {
-    [MARKER]: 1,
-    format: FORMAT,
-    casRoot: path.relative(sessionPath, casRoot).split(path.sep).join("/"),
-    bodyRef,
-    wrapper,
-    stats,
-  };
-
-  // Replace the large legacy request file only after all referenced objects exist.
-  writeManifestAtomic(filePath, manifest);
-  return manifest;
-}
-
-export function readDedupRequestLog(filePath) {
-  const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-  if (!isDedupRequestManifest(parsed)) return parsed;
-
-  const sessionPath = path.dirname(filePath);
-  const casRoot = path.resolve(sessionPath, parsed.casRoot || "../request-cas-v1");
-  const encodedBody = readObject(casRoot, parsed.bodyRef, "body_manifest");
-  const body = decodeBodyNode(encodedBody, casRoot);
-  return { ...(parsed.wrapper || {}), body };
-}
-
-export const LOCAL_REQUEST_CAS_FORMAT = FORMAT;