colonies-ts 0.1.0

package/dist/index.mjs

@@ -0,0 +1,944 @@
+// src/crypto.ts
+import { sha3_256 } from "@noble/hashes/sha3";
+import { sha256 } from "@noble/hashes/sha256";
+import { hmac } from "@noble/hashes/hmac";
+import { bytesToHex, hexToBytes, randomBytes } from "@noble/hashes/utils";
+var A = 0n;
+var N = 115792089237316195423570985008687907852837564279074904382605163141518161494337n;
+var Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240n;
+var Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424n;
+var G = [Gx, Gy];
+var P = 2n ** 256n - 2n ** 32n - 977n;
+function pad32(value) {
+  if (value.length >= 32) return value.slice(0, 32);
+  const padded = new Uint8Array(32);
+  padded.set(value, 32 - value.length);
+  return padded;
+}
+function intToBigEndian(value) {
+  if (value === 0n) return new Uint8Array([0]);
+  const hex = value.toString(16);
+  const paddedHex = hex.length % 2 ? "0" + hex : hex;
+  return hexToBytes(paddedHex);
+}
+function bigEndianToInt(value) {
+  if (value.length === 0) return 0n;
+  return BigInt("0x" + bytesToHex(value));
+}
+function inv(a, n) {
+  if (a === 0n) return 0n;
+  let lm = 1n, hm = 0n;
+  let low = (a % n + n) % n, high = n;
+  while (low > 1n) {
+    const r = high / low;
+    const nm = hm - lm * r;
+    const newVal = high - low * r;
+    hm = lm;
+    high = low;
+    lm = nm;
+    low = newVal;
+  }
+  return (lm % n + n) % n;
+}
+function toJacobian(p) {
+  return [p[0], p[1], 1n];
+}
+function fromJacobian(p) {
+  const z = inv(p[2], P);
+  const z2 = z * z % P;
+  const z3 = z2 * z % P;
+  return [(p[0] * z2 % P + P) % P, (p[1] * z3 % P + P) % P];
+}
+function jacobianDouble(p) {
+  if (p[1] === 0n) return [0n, 0n, 0n];
+  const ysq = p[1] ** 2n % P;
+  const S = 4n * p[0] * ysq % P;
+  const M = (3n * p[0] ** 2n + A * p[2] ** 4n) % P;
+  const nx = ((M ** 2n - 2n * S) % P + P) % P;
+  const ny = ((M * (S - nx) - 8n * ysq ** 2n) % P + P) % P;
+  const nz = 2n * p[1] * p[2] % P;
+  return [nx, ny, nz];
+}
+function jacobianAdd(p, q) {
+  if (p[1] === 0n) return q;
+  if (q[1] === 0n) return p;
+  const U1 = p[0] * q[2] ** 2n % P;
+  const U2 = q[0] * p[2] ** 2n % P;
+  const S1 = p[1] * q[2] ** 3n % P;
+  const S2 = q[1] * p[2] ** 3n % P;
+  if (U1 === U2) {
+    if (S1 !== S2) return [0n, 0n, 1n];
+    return jacobianDouble(p);
+  }
+  const H = ((U2 - U1) % P + P) % P;
+  const R = ((S2 - S1) % P + P) % P;
+  const H2 = H * H % P;
+  const H3 = H * H2 % P;
+  const U1H2 = U1 * H2 % P;
+  const nx = ((R ** 2n - H3 - 2n * U1H2) % P + P) % P;
+  const ny = ((R * (U1H2 - nx) - S1 * H3) % P + P) % P;
+  const nz = H * p[2] * q[2] % P;
+  return [nx, ny, nz];
+}
+function jacobianMultiply(a, n) {
+  if (a[1] === 0n || n === 0n) return [0n, 0n, 1n];
+  if (n === 1n) return a;
+  if (n < 0n || n >= N) return jacobianMultiply(a, (n % N + N) % N);
+  if (n % 2n === 0n) {
+    return jacobianDouble(jacobianMultiply(a, n / 2n));
+  } else {
+    return jacobianAdd(jacobianDouble(jacobianMultiply(a, n / 2n)), a);
+  }
+}
+function fastMultiply(a, n) {
+  return fromJacobian(jacobianMultiply(toJacobian(a), n));
+}
+function encodeRawPublicKey(rawPublicKey) {
+  const left = pad32(intToBigEndian(rawPublicKey[0]));
+  const right = pad32(intToBigEndian(rawPublicKey[1]));
+  const result = new Uint8Array(64);
+  result.set(left, 0);
+  result.set(right, 32);
+  return result;
+}
+function privateKeyToPublicKey(privateKeyBytes) {
+  const privateKeyAsNum = bigEndianToInt(privateKeyBytes);
+  if (privateKeyAsNum >= N) {
+    throw new Error("Invalid private key");
+  }
+  const rawPublicKey = fastMultiply(G, privateKeyAsNum);
+  return encodeRawPublicKey(rawPublicKey);
+}
+function deterministicGenerateK(msgHash, privateKeyBytes) {
+  const v0 = new Uint8Array(32).fill(1);
+  const k0 = new Uint8Array(32).fill(0);
+  const data1 = new Uint8Array(v0.length + 1 + privateKeyBytes.length + msgHash.length);
+  data1.set(v0, 0);
+  data1[v0.length] = 0;
+  data1.set(privateKeyBytes, v0.length + 1);
+  data1.set(msgHash, v0.length + 1 + privateKeyBytes.length);
+  const k1 = hmac(sha256, k0, data1);
+  const v1 = hmac(sha256, k1, v0);
+  const data2 = new Uint8Array(v1.length + 1 + privateKeyBytes.length + msgHash.length);
+  data2.set(v1, 0);
+  data2[v1.length] = 1;
+  data2.set(privateKeyBytes, v1.length + 1);
+  data2.set(msgHash, v1.length + 1 + privateKeyBytes.length);
+  const k2 = hmac(sha256, k1, data2);
+  const v2 = hmac(sha256, k2, v1);
+  const kb = hmac(sha256, k2, v2);
+  return bigEndianToInt(kb);
+}
+function ecdsaRawSign(msgHash, privateKeyBytes) {
+  const z = bigEndianToInt(msgHash);
+  const k = deterministicGenerateK(msgHash, privateKeyBytes);
+  const [r, y] = fastMultiply(G, k);
+  const privKeyNum = bigEndianToInt(privateKeyBytes);
+  const sRaw = inv(k, N) * (z + r * privKeyNum) % N;
+  const v = 27 + Number(y % 2n ^ (sRaw * 2n < N ? 0n : 1n));
+  const s = sRaw * 2n < N ? sRaw : N - sRaw;
+  return [v - 27, r, s];
+}
+function generatePrivateKey() {
+  const randomData = randomBytes(32);
+  const hash = sha3_256(randomData);
+  return bytesToHex(hash);
+}
+function deriveId(privateKey) {
+  const privateKeyBytes = hexToBytes(privateKey);
+  const publicKey = privateKeyToPublicKey(privateKeyBytes);
+  const publicKeyHex = "04" + bytesToHex(publicKey);
+  const encoder = new TextEncoder();
+  const hash = sha3_256(encoder.encode(publicKeyHex));
+  return bytesToHex(hash);
+}
+function sign(message, privateKey) {
+  const privateKeyBytes = hexToBytes(privateKey);
+  const encoder = new TextEncoder();
+  const msgHash = sha3_256(encoder.encode(message));
+  const [v, r, s] = ecdsaRawSign(msgHash, privateKeyBytes);
+  const vBytes = new Uint8Array([v]);
+  const rBytes = pad32(intToBigEndian(r));
+  const sBytes = pad32(intToBigEndian(s));
+  const signature = new Uint8Array(65);
+  signature.set(rBytes, 0);
+  signature.set(sBytes, 32);
+  signature.set(vBytes, 64);
+  return bytesToHex(signature);
+}
+var Crypto = class {
+  generatePrivateKey() {
+    return generatePrivateKey();
+  }
+  id(privateKey) {
+    return deriveId(privateKey);
+  }
+  sign(message, privateKey) {
+    return sign(message, privateKey);
+  }
+};
+
+// src/client.ts
+function decodeBase64Utf8(base64) {
+  const binaryStr = atob(base64);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function encodeBase64Utf8(str) {
+  const utf8Bytes = new TextEncoder().encode(str);
+  const binaryStr = String.fromCharCode(...utf8Bytes);
+  return btoa(binaryStr);
+}
+var ProcessState = /* @__PURE__ */ ((ProcessState2) => {
+  ProcessState2[ProcessState2["WAITING"] = 0] = "WAITING";
+  ProcessState2[ProcessState2["RUNNING"] = 1] = "RUNNING";
+  ProcessState2[ProcessState2["SUCCESS"] = 2] = "SUCCESS";
+  ProcessState2[ProcessState2["FAILED"] = 3] = "FAILED";
+  return ProcessState2;
+})(ProcessState || {});
+var ColoniesClient = class {
+  constructor(config) {
+    this.privateKey = null;
+    this.host = config.host;
+    this.port = config.port;
+    this.tls = config.tls ?? false;
+    this.crypto = new Crypto();
+  }
+  setPrivateKey(privateKey) {
+    this.privateKey = privateKey;
+  }
+  getBaseUrl() {
+    const protocol = this.tls ? "https" : "http";
+    return `${protocol}://${this.host}:${this.port}/api`;
+  }
+  createRPCMsg(msg) {
+    if (!this.privateKey) {
+      throw new Error("Private key not set. Call setPrivateKey() first.");
+    }
+    const payload = encodeBase64Utf8(JSON.stringify(msg));
+    const signature = this.crypto.sign(payload, this.privateKey);
+    return {
+      payloadtype: msg.msgtype,
+      payload,
+      signature
+    };
+  }
+  async sendRPC(rpcMessage) {
+    const url = this.getBaseUrl();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(rpcMessage)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorObj;
+      try {
+        errorObj = JSON.parse(errorText);
+      } catch {
+        throw new Error(`Request failed with status ${response.status}: ${response.statusText}`);
+      }
+      if (errorObj.payload) {
+        try {
+          const decodedPayload = decodeBase64Utf8(errorObj.payload);
+          const decodedError = JSON.parse(decodedPayload);
+          throw new Error(decodedError.message || JSON.stringify(decodedError));
+        } catch (e) {
+          if (e instanceof Error && e.message !== "Request failed") {
+            throw e;
+          }
+        }
+      }
+      throw new Error(JSON.stringify(errorObj));
+    }
+    const responseText = await response.text();
+    if (!responseText || responseText.trim() === "") {
+      throw new Error("Server returned empty response");
+    }
+    const rpcReplyMsg = JSON.parse(responseText);
+    const msg = JSON.parse(decodeBase64Utf8(rpcReplyMsg.payload));
+    if (rpcReplyMsg.error === true) {
+      const errorMessage = typeof msg === "object" && msg.message ? msg.message : JSON.stringify(msg);
+      throw new Error(errorMessage);
+    }
+    return msg;
+  }
+  // ==================== Colony Methods ====================
+  async getColonies() {
+    const msg = { msgtype: "getcoloniesmsg" };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getStatistics() {
+    const msg = { msgtype: "getstatisticsmsg" };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Add a new colony (requires server private key)
+   * @param colony - Colony object with colonyid and name
+   */
+  async addColony(colony) {
+    const msg = {
+      msgtype: "addcolonymsg",
+      colony
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Remove a colony (requires server private key)
+   * @param colonyName - Name of the colony to remove
+   */
+  async removeColony(colonyName) {
+    const msg = {
+      msgtype: "removecolonymsg",
+      colonyname: colonyName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Executor Methods ====================
+  async getExecutors(colonyName) {
+    const msg = {
+      msgtype: "getexecutorsmsg",
+      colonyname: colonyName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getExecutor(colonyName, executorName) {
+    const msg = {
+      msgtype: "getexecutormsg",
+      colonyname: colonyName,
+      executorname: executorName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async addExecutor(executor) {
+    const msg = {
+      msgtype: "addexecutormsg",
+      executor
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async approveExecutor(colonyName, executorName) {
+    const msg = {
+      msgtype: "approveexecutormsg",
+      colonyname: colonyName,
+      executorname: executorName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeExecutor(colonyName, executorName) {
+    const msg = {
+      msgtype: "removeexecutormsg",
+      colonyname: colonyName,
+      executorname: executorName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Process Methods ====================
+  async submitFunctionSpec(spec) {
+    const msg = {
+      msgtype: "submitfuncspecmsg",
+      spec
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getProcess(processId) {
+    const msg = {
+      msgtype: "getprocessmsg",
+      processid: processId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getProcesses(colonyName, count, state) {
+    const msg = {
+      msgtype: "getprocessesmsg",
+      colonyname: colonyName,
+      count,
+      state
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeProcess(processId) {
+    const msg = {
+      msgtype: "removeprocessmsg",
+      processid: processId,
+      all: false
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeAllProcesses(colonyName, state = -1) {
+    const msg = {
+      msgtype: "removeallprocessesmsg",
+      colonyname: colonyName,
+      state
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async assign(colonyName, timeout, executorPrvKey) {
+    const originalKey = this.privateKey;
+    this.setPrivateKey(executorPrvKey);
+    try {
+      const msg = {
+        msgtype: "assignprocessmsg",
+        colonyname: colonyName,
+        timeout
+      };
+      return this.sendRPC(this.createRPCMsg(msg));
+    } finally {
+      if (originalKey) {
+        this.setPrivateKey(originalKey);
+      }
+    }
+  }
+  async closeProcess(processId, output) {
+    const msg = {
+      msgtype: "closesuccessfulmsg",
+      processid: processId,
+      out: output
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async failProcess(processId, errors) {
+    const msg = {
+      msgtype: "closefailedmsg",
+      processid: processId,
+      errors
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Workflow Methods ====================
+  async submitWorkflowSpec(workflowSpec) {
+    const msg = {
+      msgtype: "submitworkflowspecmsg",
+      spec: workflowSpec
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getProcessGraph(processGraphId) {
+    const msg = {
+      msgtype: "getprocessgraphmsg",
+      processgraphid: processGraphId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getProcessGraphs(colonyName, count, state) {
+    const msg = {
+      msgtype: "getprocessgraphsmsg",
+      colonyname: colonyName,
+      count
+    };
+    if (state !== void 0) {
+      msg.state = state;
+    }
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeProcessGraph(processGraphId) {
+    const msg = {
+      msgtype: "removeprocessgraphmsg",
+      processgraphid: processGraphId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeAllProcessGraphs(colonyName, state) {
+    const msg = {
+      msgtype: "removeallprocessgraphsmsg",
+      colonyname: colonyName
+    };
+    if (state !== void 0) {
+      msg.state = state;
+    }
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Log Methods ====================
+  async addLog(processId, message, executorPrvKey) {
+    const originalKey = this.privateKey;
+    this.setPrivateKey(executorPrvKey);
+    try {
+      const msg = {
+        msgtype: "addlogmsg",
+        processid: processId,
+        message
+      };
+      return this.sendRPC(this.createRPCMsg(msg));
+    } finally {
+      if (originalKey) {
+        this.setPrivateKey(originalKey);
+      }
+    }
+  }
+  async getLogs(colonyName, processId, executorName, count = 100, since = 0) {
+    const msg = {
+      msgtype: "getlogsmsg",
+      colonyname: colonyName,
+      processid: processId,
+      executorname: executorName,
+      count,
+      since
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Function Methods ====================
+  async getFunctions(executorName, colonyName) {
+    const msg = {
+      msgtype: "getfunctionsmsg",
+      executorname: executorName,
+      colonyname: colonyName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Cron Methods ====================
+  async getCrons(colonyName, count = 100) {
+    const msg = {
+      msgtype: "getcronsmsg",
+      colonyname: colonyName,
+      count
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getCron(cronId) {
+    const msg = {
+      msgtype: "getcronmsg",
+      cronid: cronId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async addCron(cronSpec) {
+    const msg = {
+      msgtype: "addcronmsg",
+      cron: cronSpec
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeCron(cronId) {
+    const msg = {
+      msgtype: "removecronmsg",
+      cronid: cronId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Generator Methods ====================
+  async getGenerators(colonyName, count = 100) {
+    const msg = {
+      msgtype: "getgeneratorsmsg",
+      colonyname: colonyName,
+      count
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getGenerator(generatorId) {
+    const msg = {
+      msgtype: "getgeneratormsg",
+      generatorid: generatorId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async addGenerator(generatorSpec) {
+    const msg = {
+      msgtype: "addgeneratormsg",
+      generator: generatorSpec
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== User Methods ====================
+  async getUsers(colonyName) {
+    const msg = {
+      msgtype: "getusersmsg",
+      colonyname: colonyName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async addUser(user) {
+    const msg = {
+      msgtype: "addusermsg",
+      user
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async removeUser(colonyName, name) {
+    const msg = {
+      msgtype: "removeusermsg",
+      colonyname: colonyName,
+      name
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== File Methods ====================
+  async getFileLabels(colonyName, name = "", exact = false) {
+    const msg = {
+      msgtype: "getfilelabelsmsg",
+      colonyname: colonyName,
+      name,
+      exact
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getFiles(colonyName, label) {
+    const msg = {
+      msgtype: "getfilesmsg",
+      colonyname: colonyName,
+      label
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Attribute Methods ====================
+  async addAttribute(attribute) {
+    const msg = {
+      msgtype: "addattributemsg",
+      attribute
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  async getAttribute(attributeId) {
+    const msg = {
+      msgtype: "getattributemsg",
+      attributeid: attributeId
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Channel Methods ====================
+  /**
+   * Append a message to a process channel
+   * @param processId - ID of the process
+   * @param channelName - Name of the channel
+   * @param sequence - Client-assigned sequence number
+   * @param inReplyTo - Sequence number this message is replying to (0 if not a reply)
+   * @param payload - Message content (string or Uint8Array)
+   */
+  async channelAppend(processId, channelName, sequence, inReplyTo, payload) {
+    let payloadBytes;
+    if (typeof payload === "string") {
+      const encoder = new TextEncoder();
+      payloadBytes = Array.from(encoder.encode(payload));
+    } else {
+      payloadBytes = Array.from(payload);
+    }
+    const msg = {
+      msgtype: "channelappendmsg",
+      processid: processId,
+      name: channelName,
+      sequence,
+      inreplyto: inReplyTo,
+      payload: payloadBytes
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Read messages from a process channel
+   * @param processId - ID of the process
+   * @param channelName - Name of the channel
+   * @param afterSeq - Read messages after this sequence number (use 0 for all)
+   * @param limit - Maximum number of messages to return (0 for no limit)
+   */
+  async channelRead(processId, channelName, afterSeq, limit) {
+    const msg = {
+      msgtype: "channelreadmsg",
+      processid: processId,
+      name: channelName,
+      afterseq: afterSeq,
+      limit
+    };
+    const response = await this.sendRPC(this.createRPCMsg(msg));
+    if (Array.isArray(response)) {
+      return response.map((entry) => ({
+        ...entry,
+        payload: typeof entry.payload === "string" ? (() => {
+          try {
+            const binaryStr = atob(entry.payload);
+            const bytes = new Uint8Array(binaryStr.length);
+            for (let i = 0; i < binaryStr.length; i++) {
+              bytes[i] = binaryStr.charCodeAt(i);
+            }
+            return new TextDecoder("utf-8").decode(bytes);
+          } catch {
+            return entry.payload;
+          }
+        })() : Array.isArray(entry.payload) ? new TextDecoder("utf-8").decode(new Uint8Array(entry.payload)) : entry.payload
+      }));
+    }
+    return response || [];
+  }
+  /**
+   * Subscribe to a channel using WebSocket for real-time updates
+   * @param processId - ID of the process
+   * @param channelName - Name of the channel
+   * @param afterSeq - Start reading after this sequence number
+   * @param timeout - Timeout in seconds for the subscription
+   * @param onMessage - Callback for new messages
+   * @param onError - Callback for errors
+   * @param onClose - Callback when connection closes
+   * @returns WebSocket instance for cleanup
+   */
+  subscribeChannel(processId, channelName, afterSeq, timeout, onMessage, onError, onClose) {
+    if (!this.privateKey) {
+      throw new Error("Private key not set. Call setPrivateKey() first.");
+    }
+    const wsProtocol = this.tls ? "wss" : "ws";
+    const wsUrl = `${wsProtocol}://${this.host}:${this.port}/pubsub`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      const msg = {
+        msgtype: "subscribechannelmsg",
+        processid: processId,
+        name: channelName,
+        afterseq: afterSeq,
+        timeout
+      };
+      const rpcMsg = this.createRPCMsg(msg);
+      ws.send(JSON.stringify(rpcMsg));
+    };
+    ws.onmessage = (event) => {
+      try {
+        const rpcReply = JSON.parse(event.data);
+        if (rpcReply.error) {
+          const errorPayload = JSON.parse(decodeBase64Utf8(rpcReply.payload));
+          onError(new Error(errorPayload.message || "WebSocket error"));
+          return;
+        }
+        const data = JSON.parse(decodeBase64Utf8(rpcReply.payload));
+        if (Array.isArray(data)) {
+          const entries = data.map((entry) => ({
+            ...entry,
+            payload: typeof entry.payload === "string" ? (() => {
+              try {
+                const binaryStr = atob(entry.payload);
+                const bytes = new Uint8Array(binaryStr.length);
+                for (let i = 0; i < binaryStr.length; i++) {
+                  bytes[i] = binaryStr.charCodeAt(i);
+                }
+                return new TextDecoder("utf-8").decode(bytes);
+              } catch {
+                return entry.payload;
+              }
+            })() : Array.isArray(entry.payload) ? new TextDecoder("utf-8").decode(new Uint8Array(entry.payload)) : entry.payload
+          }));
+          const errorEntry = entries.find((e) => e.error);
+          if (errorEntry) {
+            onError(new Error(errorEntry.error));
+            return;
+          }
+          onMessage(entries);
+        }
+      } catch (err) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+    ws.onerror = () => {
+      onError(new Error("WebSocket connection error"));
+    };
+    ws.onclose = () => {
+      onClose();
+    };
+    return ws;
+  }
+  // ==================== Blueprint Definition Methods ====================
+  /**
+   * Add a blueprint definition
+   * @param definition - Blueprint definition object
+   */
+  async addBlueprintDefinition(definition) {
+    const msg = {
+      msgtype: "addblueprintdefinitionmsg",
+      blueprintdefinition: definition
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Get a blueprint definition by name
+   * @param colonyName - Name of the colony
+   * @param name - Name of the blueprint definition
+   */
+  async getBlueprintDefinition(colonyName, name) {
+    const msg = {
+      msgtype: "getblueprintdefinitionmsg",
+      colonyname: colonyName,
+      name
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Get all blueprint definitions in a colony
+   * @param colonyName - Name of the colony
+   */
+  async getBlueprintDefinitions(colonyName) {
+    const msg = {
+      msgtype: "getblueprintdefinitionsmsg",
+      colonyname: colonyName
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Remove a blueprint definition
+   * @param colonyName - Name of the colony (namespace)
+   * @param name - Name of the blueprint definition to remove
+   */
+  async removeBlueprintDefinition(colonyName, name) {
+    const msg = {
+      msgtype: "removeblueprintdefinitionmsg",
+      namespace: colonyName,
+      name
+    };
+    await this.sendRPC(this.createRPCMsg(msg));
+  }
+  // ==================== Blueprint Methods ====================
+  /**
+   * Add a blueprint instance
+   * @param blueprint - Blueprint object
+   */
+  async addBlueprint(blueprint) {
+    const msg = {
+      msgtype: "addblueprintmsg",
+      blueprint
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Get a blueprint by name
+   * @param colonyName - Name of the colony (namespace)
+   * @param name - Name of the blueprint
+   */
+  async getBlueprint(colonyName, name) {
+    const msg = {
+      msgtype: "getblueprintmsg",
+      namespace: colonyName,
+      name
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Get blueprints in a colony, optionally filtered by kind and location
+   * @param colonyName - Name of the colony (namespace)
+   * @param kind - Optional kind filter
+   * @param location - Optional location filter
+   */
+  async getBlueprints(colonyName, kind, location) {
+    const msg = {
+      msgtype: "getblueprintsmsg",
+      namespace: colonyName
+    };
+    if (kind) msg.kind = kind;
+    if (location) msg.locationname = location;
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Update an existing blueprint
+   * @param blueprint - Updated blueprint object
+   * @param forceGeneration - Force generation bump even if spec unchanged
+   */
+  async updateBlueprint(blueprint, forceGeneration = false) {
+    const msg = {
+      msgtype: "updateblueprintmsg",
+      blueprint,
+      forcegeneration: forceGeneration
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Remove a blueprint
+   * @param colonyName - Name of the colony (namespace)
+   * @param name - Name of the blueprint to remove
+   */
+  async removeBlueprint(colonyName, name) {
+    const msg = {
+      msgtype: "removeblueprintmsg",
+      namespace: colonyName,
+      name
+    };
+    await this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Update blueprint status (current state)
+   * @param colonyName - Name of the colony
+   * @param name - Name of the blueprint
+   * @param status - Status object representing current state
+   */
+  async updateBlueprintStatus(colonyName, name, status) {
+    const msg = {
+      msgtype: "updateblueprintstatusmsg",
+      colonyname: colonyName,
+      blueprintname: name,
+      status
+    };
+    await this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Trigger reconciliation for a blueprint
+   * @param colonyName - Name of the colony (namespace)
+   * @param name - Name of the blueprint
+   * @param force - Force reconciliation even if no changes detected
+   */
+  async reconcileBlueprint(colonyName, name, force = false) {
+    const msg = {
+      msgtype: "reconcileblueprintmsg",
+      namespace: colonyName,
+      name,
+      force
+    };
+    return this.sendRPC(this.createRPCMsg(msg));
+  }
+  /**
+   * Subscribe to process state changes using WebSocket
+   * Use this to wait for a process to be assigned (RUNNING state) before subscribing to channels
+   * @param colonyName - Name of the colony
+   * @param processId - ID of the process to watch
+   * @param state - Target state to wait for (0=WAITING, 1=RUNNING, 2=SUCCESS, 3=FAILED)
+   * @param timeout - Timeout in seconds for the subscription
+   * @param onProcess - Callback when process reaches the target state
+   * @param onError - Callback for errors
+   * @param onClose - Callback when connection closes
+   * @returns WebSocket instance for cleanup
+   */
+  subscribeProcess(colonyName, processId, state, timeout, onProcess, onError, onClose) {
+    if (!this.privateKey) {
+      throw new Error("Private key not set. Call setPrivateKey() first.");
+    }
+    const wsProtocol = this.tls ? "wss" : "ws";
+    const wsUrl = `${wsProtocol}://${this.host}:${this.port}/pubsub`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      const msg = {
+        msgtype: "subscribeprocessmsg",
+        colonyname: colonyName,
+        processid: processId,
+        executortype: "",
+        state,
+        timeout
+      };
+      const rpcMsg = this.createRPCMsg(msg);
+      ws.send(JSON.stringify(rpcMsg));
+    };
+    ws.onmessage = (event) => {
+      try {
+        const rpcReply = JSON.parse(event.data);
+        if (rpcReply.error) {
+          const errorPayload = JSON.parse(decodeBase64Utf8(rpcReply.payload));
+          onError(new Error(errorPayload.message || "WebSocket error"));
+          return;
+        }
+        const process = JSON.parse(decodeBase64Utf8(rpcReply.payload));
+        onProcess(process);
+      } catch (err) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+    ws.onerror = () => {
+      onError(new Error("WebSocket connection error"));
+    };
+    ws.onclose = () => {
+      onClose();
+    };
+    return ws;
+  }
+};
+export {
+  ColoniesClient,
+  Crypto,
+  ProcessState,
+  deriveId,
+  generatePrivateKey,
+  sign
+};
+//# sourceMappingURL=index.mjs.map