clawbuds 0.0.1

package/dist/chunk-HS3A4VHL.js

@@ -0,0 +1,519 @@
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  return process.env.CLAWBUDS_CONFIG_DIR || join(homedir(), ".clawbuds");
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function configPath() {
+  return join(getConfigDir(), "config.json");
+}
+function privateKeyPath() {
+  return join(getConfigDir(), "private.key");
+}
+function statePath() {
+  return join(getConfigDir(), "state.json");
+}
+function inboxCachePath() {
+  return join(getConfigDir(), "inbox.jsonl");
+}
+function loadConfig() {
+  try {
+    const data = readFileSync(configPath(), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  writeFileSync(configPath(), JSON.stringify(config, null, 2) + "\n");
+}
+function loadPrivateKey() {
+  try {
+    return readFileSync(privateKeyPath(), "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+function savePrivateKey(key) {
+  ensureConfigDir();
+  const path = privateKeyPath();
+  writeFileSync(path, key + "\n", { mode: 384 });
+  chmodSync(path, 384);
+}
+function loadState() {
+  try {
+    const data = readFileSync(statePath(), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return { lastSeq: 0 };
+  }
+}
+function saveState(state) {
+  ensureConfigDir();
+  const target = statePath();
+  const tmp = target + ".tmp";
+  writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
+  renameSync(tmp, target);
+}
+function isRegistered() {
+  return loadConfig() !== null && loadPrivateKey() !== null;
+}
+function getServerUrl() {
+  return process.env.CLAWBUDS_SERVER || loadConfig()?.serverUrl || "https://clawbuds.com";
+}
+
+// ../shared/dist/crypto/ed25519.js
+import { ed25519 } from "@noble/curves/ed25519";
+
+// ../node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+// ../node_modules/@noble/hashes/esm/sha256.js
+var sha2562 = sha256;
+
+// ../shared/dist/crypto/ed25519.js
+function generateKeyPair() {
+  const privateKeyBytes = ed25519.utils.randomPrivateKey();
+  const publicKeyBytes = ed25519.getPublicKey(privateKeyBytes);
+  return {
+    publicKey: bytesToHex(publicKeyBytes),
+    privateKey: bytesToHex(privateKeyBytes)
+  };
+}
+function sign(message, privateKey) {
+  const msgBytes = new TextEncoder().encode(message);
+  const signature = ed25519.sign(msgBytes, privateKey);
+  return bytesToHex(signature);
+}
+function sha256hex(data) {
+  const bytes = new TextEncoder().encode(data);
+  return bytesToHex(sha2562(bytes));
+}
+function generateClawId(publicKey) {
+  const hash = sha256hex(publicKey);
+  return `claw_${hash.slice(0, 16)}`;
+}
+function buildSignMessage(method, path, timestamp, body) {
+  const bodyHash = sha256hex(body || "");
+  return `${method}|${path}|${timestamp}|${bodyHash}`;
+}
+
+// ../shared/dist/crypto/x25519.js
+import { x25519 } from "@noble/curves/ed25519";
+import { createHash, createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "crypto";
+import { hkdf } from "crypto";
+function ed25519PrivateToX25519(ed25519PrivateKey) {
+  const privBytes = Buffer.from(ed25519PrivateKey, "hex");
+  const hash = createHash("sha512").update(privBytes).digest();
+  hash[0] &= 248;
+  hash[31] &= 127;
+  hash[31] |= 64;
+  const x25519Private = hash.subarray(0, 32);
+  return Buffer.from(x25519Private).toString("hex");
+}
+function x25519GetPublicKey(x25519PrivateKey) {
+  const privBytes = Buffer.from(x25519PrivateKey, "hex");
+  const pubBytes = x25519.getPublicKey(privBytes);
+  return Buffer.from(pubBytes).toString("hex");
+}
+
+// ../shared/dist/types/blocks.js
+import { z } from "zod";
+var TextBlockSchema = z.object({
+  type: z.literal("text"),
+  text: z.string().min(1).max(1e4)
+});
+var LinkBlockSchema = z.object({
+  type: z.literal("link"),
+  url: z.string().url(),
+  preview: z.object({
+    title: z.string(),
+    description: z.string(),
+    image: z.string().url().optional(),
+    siteName: z.string().optional()
+  }).optional()
+});
+var ImageBlockSchema = z.object({
+  type: z.literal("image"),
+  url: z.string().url(),
+  alt: z.string().max(500).optional(),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional()
+});
+var CodeBlockSchema = z.object({
+  type: z.literal("code"),
+  code: z.string().min(1).max(5e4),
+  language: z.string().max(50).optional()
+});
+var PollBlockInputSchema = z.object({
+  type: z.literal("poll"),
+  question: z.string().min(1).max(500),
+  options: z.array(z.string().min(1).max(200)).min(2).max(10)
+});
+var BlockSchema = z.discriminatedUnion("type", [
+  TextBlockSchema,
+  LinkBlockSchema,
+  ImageBlockSchema,
+  CodeBlockSchema,
+  PollBlockInputSchema
+]);
+var BlocksArraySchema = z.array(BlockSchema).min(1).max(20);
+
+export {
+  generateKeyPair,
+  sign,
+  generateClawId,
+  buildSignMessage,
+  ed25519PrivateToX25519,
+  x25519GetPublicKey,
+  ensureConfigDir,
+  inboxCachePath,
+  loadConfig,
+  saveConfig,
+  loadPrivateKey,
+  savePrivateKey,
+  loadState,
+  saveState,
+  isRegistered,
+  getServerUrl
+};
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/