@forbocai/core 0.5.7 → 0.5.8

package/dist/ans104-QFXL554Z.mjs

@@ -0,0 +1,190 @@
+import "./chunk-7P6ASYW6.mjs";
+
+// src/ans104.ts
+import base64url from "base64url";
+import { Buffer } from "buffer";
+import { constants, createHash, createSign } from "crypto";
+import { jwkTopem } from "arweave/node/lib/crypto/pem";
+var SIGNATURE_TYPE_ARWEAVE = 1;
+var SIGNATURE_LENGTH = 512;
+var OWNER_LENGTH = 512;
+var MAX_TAG_BYTES = 4096;
+var stringToBuffer = (value) => Buffer.from(value);
+var concatBuffers = (buffers) => Buffer.concat(buffers);
+var longToNByteArray = (bytes, long) => {
+  if (long < 0) throw new Error("Array is unsigned, cannot represent -ve numbers");
+  if (long > 2 ** (bytes * 8) - 1) throw new Error(`Number ${long} is too large for an array of ${bytes} bytes`);
+  const step = (index, currentLong, acc) => index >= bytes ? acc : step(index + 1, (currentLong - (currentLong & 255)) / 256, [...acc, currentLong & 255]);
+  return new Uint8Array(step(0, long, []));
+};
+var longTo8ByteArray = (long) => longToNByteArray(8, long);
+var shortTo2ByteArray = (short) => longToNByteArray(2, short);
+var createTap = (buf = Buffer.alloc(MAX_TAG_BYTES), pos = 0) => ({ buf, pos });
+var writeLongStep = (buf, pos, val) => {
+  const byte = val & 127;
+  const nextVal = val >> 7;
+  if (nextVal !== 0) {
+    buf[pos] = byte | 128;
+    return writeLongStep(buf, pos + 1, nextVal);
+  } else {
+    buf[pos] = byte;
+    return pos + 1;
+  }
+};
+var writeLongLargeStep = (buf, pos, val) => {
+  const byte = val & 127;
+  const nextVal = val / 128;
+  if (nextVal >= 1) {
+    buf[pos] = byte | 128;
+    return writeLongLargeStep(buf, pos + 1, nextVal);
+  } else {
+    buf[pos] = byte;
+    return pos + 1;
+  }
+};
+var writeLong = (tap, n) => {
+  const newBuf = Buffer.from(tap.buf);
+  let newPos;
+  if (n >= -1073741824 && n < 1073741824) {
+    const m = n >= 0 ? n << 1 : ~n << 1 | 1;
+    newPos = writeLongStep(newBuf, tap.pos, m);
+  } else {
+    const f = n >= 0 ? n * 2 : -n * 2 - 1;
+    newPos = writeLongLargeStep(newBuf, tap.pos, f);
+  }
+  return { buf: newBuf, pos: newPos };
+};
+var writeString = (tap, s) => {
+  const len = Buffer.byteLength(s);
+  const t1 = writeLong(tap, len);
+  if (t1.pos + len > t1.buf.length) return t1;
+  const newBuf = Buffer.from(t1.buf);
+  newBuf.write(s, t1.pos, len, "utf8");
+  return { buf: newBuf, pos: t1.pos + len };
+};
+var writeTagsRecursive = (tap, tags, index) => {
+  if (index >= tags.length) return tap;
+  const tag = tags[index];
+  if (typeof tag?.name !== "string" || typeof tag?.value !== "string") {
+    throw new Error(`Invalid tag format for ${tag}, expected {name:string, value: string}`);
+  }
+  const t1 = writeString(tap, tag.name);
+  const t2 = writeString(t1, tag.value);
+  return writeTagsRecursive(t2, tags, index + 1);
+};
+var writeTags = (tap, tags) => {
+  if (!Array.isArray(tags)) throw new Error("input must be array");
+  const t1 = tags.length > 0 ? writeLong(tap, tags.length) : tap;
+  const t2 = tags.length > 0 ? writeTagsRecursive(t1, tags, 0) : t1;
+  return writeLong(t2, 0);
+};
+var tapToBuffer = (tap) => {
+  if (tap.pos > tap.buf.length) throw new Error(`Too many tag bytes (${tap.pos} > ${tap.buf.length})`);
+  const buffer = Buffer.alloc(tap.pos);
+  tap.buf.copy(buffer, 0, 0, tap.pos);
+  return buffer;
+};
+var serializeTags = (tags) => {
+  if (tags?.length === 0) return Buffer.allocUnsafe(0);
+  return tapToBuffer(writeTags(createTap(), tags));
+};
+var hash = (data, algorithm) => {
+  const algo = algorithm === "SHA-256" ? "sha256" : "sha384";
+  return createHash(algo).update(data).digest();
+};
+var deepHashChunks = async (chunks, acc) => {
+  if (chunks.length < 1) return acc;
+  const h = await deepHash(chunks[0]);
+  const hashPair = concatBuffers([acc, h]);
+  return deepHashChunks(chunks.slice(1), hash(hashPair, "SHA-384"));
+};
+var deepHash = async (data) => {
+  if (Array.isArray(data)) {
+    const tag2 = concatBuffers([stringToBuffer("list"), stringToBuffer(data.length.toString())]);
+    return deepHashChunks(data, hash(tag2, "SHA-384"));
+  }
+  const _data = data;
+  const tag = concatBuffers([stringToBuffer("blob"), stringToBuffer(_data.byteLength.toString())]);
+  const taggedHash = concatBuffers([hash(tag, "SHA-384"), hash(_data, "SHA-384")]);
+  return hash(taggedHash, "SHA-384");
+};
+var getSignatureData = (signatureType, rawOwner, rawTarget, rawAnchor, rawTags, rawData) => deepHash([
+  stringToBuffer("dataitem"),
+  stringToBuffer("1"),
+  stringToBuffer(signatureType.toString()),
+  rawOwner,
+  rawTarget,
+  rawAnchor,
+  rawTags,
+  rawData
+]);
+var signData = (pemKey, message) => createSign("sha256").update(message).sign({
+  key: pemKey,
+  padding: constants.RSA_PKCS1_PSS_PADDING
+});
+var getOwner = (jwk) => base64url.toBuffer(jwk.n);
+var getPem = (jwk) => {
+  const pem = jwkTopem(jwk);
+  return typeof pem === "string" ? pem : pem.toString();
+};
+var assembleDataItem = (rawOwner, rawTarget, rawAnchor, rawTags, rawData, opts) => {
+  const targetLength = 1 + (rawTarget?.byteLength ?? 0);
+  const anchorLength = 1 + (rawAnchor?.byteLength ?? 0);
+  const tagsLength = 16 + (rawTags ? rawTags.byteLength : 0);
+  const dataLength = rawData.byteLength;
+  const length = 2 + SIGNATURE_LENGTH + OWNER_LENGTH + targetLength + anchorLength + tagsLength + dataLength;
+  const bytes = Buffer.alloc(length);
+  bytes.set(shortTo2ByteArray(SIGNATURE_TYPE_ARWEAVE), 0);
+  bytes.set(new Uint8Array(SIGNATURE_LENGTH).fill(0), 2);
+  bytes.set(rawOwner, 2 + SIGNATURE_LENGTH);
+  const position = 2 + SIGNATURE_LENGTH + OWNER_LENGTH;
+  bytes[position] = rawTarget.length > 0 ? 1 : 0;
+  if (rawTarget.length > 0) {
+    if (rawTarget.byteLength !== 32) throw new Error("Target must be 32 bytes");
+    bytes.set(rawTarget, position + 1);
+  }
+  const anchorStart = position + targetLength;
+  let tagsStart = anchorStart + 1;
+  bytes[anchorStart] = rawAnchor.length > 0 ? 1 : 0;
+  if (rawAnchor.length > 0) {
+    tagsStart += rawAnchor.byteLength;
+    if (rawAnchor.byteLength !== 32) throw new Error("Anchor must be 32 bytes");
+    bytes.set(rawAnchor, anchorStart + 1);
+  }
+  bytes.set(longTo8ByteArray(opts?.tags?.length ?? 0), tagsStart);
+  bytes.set(longTo8ByteArray(rawTags?.byteLength ?? 0), tagsStart + 8);
+  if (rawTags.length > 0) {
+    bytes.set(rawTags, tagsStart + 16);
+  }
+  const dataStart = tagsStart + tagsLength;
+  bytes.set(rawData, dataStart);
+  return bytes;
+};
+var createArweaveDataItem = async (data, jwk, opts) => {
+  const rawOwner = getOwner(jwk);
+  if (rawOwner.byteLength !== OWNER_LENGTH) {
+    throw new Error(`Owner must be ${OWNER_LENGTH} bytes, but was ${rawOwner.byteLength}`);
+  }
+  const rawTarget = opts?.target ? base64url.toBuffer(opts.target) : Buffer.alloc(0);
+  const rawAnchor = opts?.anchor ? Buffer.from(opts.anchor) : Buffer.alloc(0);
+  const rawTags = (opts?.tags?.length ?? 0) > 0 ? serializeTags(opts?.tags) : Buffer.alloc(0);
+  const rawData = typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
+  const signatureData = await getSignatureData(
+    SIGNATURE_TYPE_ARWEAVE,
+    rawOwner,
+    rawTarget,
+    rawAnchor,
+    rawTags,
+    rawData
+  );
+  const signature = signData(getPem(jwk), signatureData);
+  const bytes = assembleDataItem(rawOwner, rawTarget, rawAnchor, rawTags, rawData, opts);
+  bytes.set(signature, 2);
+  return {
+    id: base64url.encode(hash(signature, "SHA-256")),
+    raw: bytes
+  };
+};
+export {
+  createArweaveDataItem
+};

package/dist/chunk-M3F3ED7H.mjs

@@ -0,0 +1,83 @@
+// src/soul.ts
+var createSoul = (id, name, persona, state, memories = []) => ({
+  id,
+  version: "1.0.0",
+  name,
+  persona,
+  state: { ...state },
+  memories: [...memories]
+});
+var serializeSoul = (soul) => JSON.stringify(soul, null, 2);
+var deserializeSoul = (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.id || !parsed.persona || !parsed.state) {
+    throw new Error("Invalid Soul format: missing required fields");
+  }
+  return {
+    id: parsed.id,
+    version: parsed.version || "1.0.0",
+    name: parsed.name || "Unknown",
+    persona: parsed.persona,
+    state: parsed.state,
+    memories: parsed.memories || [],
+    signature: parsed.signature
+  };
+};
+var exportSoul = async (agentId, _soul, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({})
+    // Future: allow specifying memories to include
+  });
+  if (!response.ok) {
+    throw new Error(`Soul export failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return {
+    txId: data.txId,
+    url: data.url,
+    soul: _soul
+    // Return the local soul data as context
+  };
+};
+var importSoulFromArweave = async (txId, config = {}) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const response = await fetch(`${apiUrl}/souls/${txId}`);
+  if (!response.ok) throw new Error(`Import failed: ${response.statusText}`);
+  const data = await response.json();
+  return data;
+};
+var getSoulList = async (limit = 50, apiUrl = "https://api.forboc.ai") => {
+  const response = await fetch(`${apiUrl}/souls?limit=${limit}`);
+  if (!response.ok) return [];
+  const data = await response.json();
+  return data.souls || [];
+};
+var createSoulInstance = (id, name, persona, state, memories = []) => {
+  const soulData = createSoul(id, name, persona, state, memories);
+  return {
+    export: (config) => exportSoul(id, soulData, config),
+    toJSON: () => ({ ...soulData })
+  };
+};
+var validateSoul = (soul) => {
+  const errors = [
+    !soul.id && "Missing id",
+    !soul.persona && "Missing persona",
+    !soul.state && "Missing state"
+  ].filter((e) => !!e);
+  return { valid: errors.length === 0, errors };
+};
+
+export {
+  createSoul,
+  serializeSoul,
+  deserializeSoul,
+  exportSoul,
+  importSoulFromArweave,
+  getSoulList,
+  createSoulInstance,
+  validateSoul
+};