@zetaloop/chappie 0.4.1 → 1.0.0

package/dist/chunk-EIPDEA3I.js

@@ -0,0 +1,286 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// src/ipc.ts
+import { createHash } from "node:crypto";
+import { once } from "node:events";
+import { lstat, unlink } from "node:fs/promises";
+import {
+  createConnection,
+  createServer
+} from "node:net";
+import { join, resolve } from "node:path";
+var defaultPort = 24274;
+function ipcEndpoint(root) {
+  const directory = resolve(root);
+  if (process.platform !== "win32") return join(directory, "broker.sock");
+  const identity = directory.replaceAll("\\", "/").toLowerCase();
+  return String.raw`\\.\pipe\chappie-${createHash("sha256").update(identity).digest("hex").slice(0, 16)}`;
+}
+var JsonLinePeer = class {
+  #socket;
+  #onMessage;
+  #onClose;
+  #buffer = "";
+  #closed = false;
+  constructor(socket, onMessage, onClose) {
+    this.#socket = socket;
+    this.#onMessage = onMessage;
+    this.#onClose = onClose;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => this.#receive(chunk));
+    socket.once("close", () => {
+      this.#closed = true;
+      this.#onClose();
+    });
+    socket.on("error", () => {
+    });
+  }
+  get closed() {
+    return this.#closed;
+  }
+  send(message) {
+    const line = `${JSON.stringify(message)}
+`;
+    return new Promise((resolveWrite, rejectWrite) => {
+      if (this.#closed) {
+        rejectWrite(new Error("Chappie IPC connection is closed"));
+        return;
+      }
+      this.#socket.write(line, (error) => {
+        if (error) rejectWrite(error);
+        else resolveWrite();
+      });
+    });
+  }
+  close() {
+    if (!this.#closed) this.#socket.end();
+  }
+  #receive(chunk) {
+    this.#buffer += chunk;
+    let end = this.#buffer.indexOf("\n");
+    while (end !== -1) {
+      const line = this.#buffer.slice(0, end);
+      this.#buffer = this.#buffer.slice(end + 1);
+      if (line.length > 0) {
+        void Promise.resolve().then(() => this.#onMessage(JSON.parse(line))).catch((error) => {
+          this.#socket.destroy(
+            error instanceof Error ? error : new Error(String(error))
+          );
+        });
+      }
+      end = this.#buffer.indexOf("\n");
+    }
+  }
+};
+var IpcServer = class {
+  #endpoint;
+  #onMessage;
+  #onClose;
+  #peers = /* @__PURE__ */ new Set();
+  #servers = /* @__PURE__ */ new Set();
+  constructor(directory, onMessage, onClose) {
+    this.#endpoint = ipcEndpoint(directory);
+    this.#onMessage = onMessage;
+    this.#onClose = onClose;
+  }
+  async start(network = false) {
+    if (this.#servers.size > 0) return;
+    if (process.platform !== "win32") await prepareUnixSocket(this.#endpoint);
+    try {
+      const local = this.#createServer();
+      await once(local.listen(this.#endpoint), "listening");
+      this.#servers.add(local);
+      if (!network) return;
+      const remote = this.#createServer();
+      await once(
+        remote.listen(network === true ? defaultPort : network),
+        "listening"
+      );
+      this.#servers.add(remote);
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+  async close() {
+    for (const peer of this.#peers) peer.close();
+    this.#peers.clear();
+    const servers = [...this.#servers];
+    this.#servers.clear();
+    await Promise.all(servers.map(closeServer));
+  }
+  #createServer() {
+    return createServer((socket) => {
+      let peer;
+      peer = new JsonLinePeer(
+        socket,
+        (message) => this.#onMessage(peer, message),
+        () => {
+          this.#peers.delete(peer);
+          this.#onClose(peer);
+        }
+      );
+      this.#peers.add(peer);
+    });
+  }
+};
+var IpcClient = class {
+  #endpoint;
+  #remote;
+  #callbacks;
+  #peer;
+  #opening;
+  #controller;
+  #retry;
+  #closed = false;
+  constructor(directory, remote, callbacks) {
+    this.#endpoint = ipcEndpoint(directory);
+    this.#remote = remote;
+    this.#callbacks = callbacks;
+  }
+  get connected() {
+    return this.#peer !== void 0 && !this.#peer.closed;
+  }
+  start() {
+    void this.connect().catch(() => {
+    });
+  }
+  connect() {
+    if (this.#closed)
+      return Promise.reject(new Error("Chappie IPC client is closed"));
+    if (this.connected) return Promise.resolve();
+    if (this.#opening) return this.#opening;
+    clearTimeout(this.#retry);
+    this.#retry = void 0;
+    const controller = new AbortController();
+    this.#controller = controller;
+    this.#opening = this.#open(controller.signal).finally(() => {
+      this.#opening = void 0;
+      if (this.#controller === controller) this.#controller = void 0;
+    });
+    return this.#opening;
+  }
+  send(message) {
+    const peer = this.#peer;
+    if (!peer || peer.closed)
+      return Promise.reject(new Error("Chappie broker is not running"));
+    return peer.send(message);
+  }
+  close() {
+    this.#closed = true;
+    clearTimeout(this.#retry);
+    this.#retry = void 0;
+    this.#controller?.abort(new Error("Chappie IPC client is closed"));
+    this.#controller = void 0;
+    this.#peer?.close();
+    this.#peer = void 0;
+  }
+  async #open(signal) {
+    let socket;
+    let failure = new Error("Chappie disconnected");
+    try {
+      socket = this.#remote ? createConnection(networkEndpoint(this.#remote)) : createConnection(this.#endpoint);
+      await once(socket, "connect", { signal });
+    } catch (error) {
+      socket?.destroy();
+      this.#scheduleReconnect();
+      signal.throwIfAborted();
+      throw error;
+    }
+    let peer;
+    peer = new JsonLinePeer(
+      socket,
+      (message) => this.#callbacks.onMessage(message),
+      () => {
+        if (this.#peer !== peer) return;
+        this.#peer = void 0;
+        if (!this.#closed) {
+          this.#callbacks.onClose(failure);
+          this.#scheduleReconnect();
+        }
+      }
+    );
+    this.#peer = peer;
+    try {
+      await this.#callbacks.onOpen();
+    } catch (error) {
+      failure = error instanceof Error ? error : new Error(String(error));
+      peer.close();
+      throw failure;
+    }
+  }
+  #scheduleReconnect() {
+    if (this.#closed || this.#retry) return;
+    this.#retry = setTimeout(() => {
+      this.#retry = void 0;
+      void this.connect().catch(() => {
+      });
+    }, 500);
+    this.#retry.unref();
+  }
+};
+function closeServer(server) {
+  return new Promise(
+    (resolveClose, rejectClose) => server.close((error) => error ? rejectClose(error) : resolveClose())
+  );
+}
+function networkEndpoint(value) {
+  const url = new URL(`tcp://${value}`);
+  if (url.username || url.password || url.pathname || url.search || url.hash)
+    throw new Error(`Invalid Chappie broker address: ${value}`);
+  const host = url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname;
+  if (!host) throw new Error(`Invalid Chappie broker address: ${value}`);
+  return { host, port: url.port ? Number(url.port) : defaultPort };
+}
+async function prepareUnixSocket(endpoint) {
+  try {
+    await lstat(endpoint);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  if (await endpointAcceptsConnections(endpoint)) {
+    const error = new Error(
+      `Chappie broker is already listening at ${endpoint}`
+    );
+    error.code = "EADDRINUSE";
+    throw error;
+  }
+  await unlink(endpoint);
+}
+function endpointAcceptsConnections(endpoint) {
+  return new Promise((resolveProbe, rejectProbe) => {
+    const socket = createConnection(endpoint);
+    socket.once("connect", () => {
+      socket.end();
+      resolveProbe(true);
+    });
+    socket.once("error", (error) => {
+      socket.destroy();
+      if (error.code === "ECONNREFUSED" || error.code === "ENOENT")
+        resolveProbe(false);
+      else rejectProbe(error);
+    });
+  });
+}
+
+// src/activity.ts
+function source(clientId, requestId, label = "ChatGPT") {
+  return {
+    clientId,
+    label,
+    ...typeof requestId === "string" ? { requestId } : {}
+  };
+}
+function sourceLabel({ clientId, label, requestId }) {
+  const workflow = requestId?.match(/^wfr_([^/]+)\//)?.[1];
+  return `${label} ${clientId.slice(-4)}${workflow ? `(${workflow.slice(-4)})` : ""}`;
+}
+
+export {
+  source,
+  sourceLabel,
+  ipcEndpoint,
+  IpcServer,
+  IpcClient
+};