chore(release): 0.0.2-develop.1 [skip ci]

## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/kernel-swarm-client/compare/v0.0.1...v0.0.2-develop.1) (2023-07-01)

### Reverts

* Revert "*Change end to close" ([b5a81d5](b5a81d51ab))

.github/workflows/ci.yml

@@ -0,0 +1,13 @@
+name: Build/Publish
+
+on:
+    push:
+        branches:
+            - master
+            - develop
+            - develop-*
+
+jobs:
+    main:
+        uses: lumeweb/github-node-deploy-workflow/.github/workflows/main.yml@master
+        secrets: inherit

.presetterrc.json

@@ -0,0 +1,5 @@
+{
+  "preset": [
+    "@lumeweb/node-library-preset"
+  ]
+}

CHANGELOG.md

@@ -0,0 +1,6 @@
+## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/kernel-swarm-client/compare/v0.0.1...v0.0.2-develop.1) (2023-07-01)
+
+
+### Reverts
+
+* Revert "*Change end to close" ([b5a81d5](https://git.lumeweb.com/LumeWeb/kernel-swarm-client/commit/b5a81d51ab490e5e8f405a18a5859f624d7b0b93))

package.json

@@ -1,16 +1,32 @@
 {
-    "name": "@lumeweb/kernel-dht-client",
-    "version": "0.1.0",
+    "name": "@lumeweb/kernel-swarm-client",
+    "version": "0.0.2-develop.1",
     "type": "module",
-    "main": "dist/index.js",
-    "dependencies": {
-        "buffer": "^6.0.3",
-        "libkernel": "^0.1.43",
-        "libkmodule": "^0.2.44",
-        "libskynet": "^0.0.62"
+    "main": "lib/index.js",
+    "repository": {
+        "type": "git",
+        "url": "gitea@git.lumeweb.com:LumeWeb/kernel-swarm-client.git"
     },
     "devDependencies": {
-        "@types/node": "^18.0.6",
-        "prettier": "^2.7.1"
+        "@lumeweb/node-library-preset": "^0.2.7",
+        "@types/b4a": "^1.6.0",
+        "presetter": "*"
+    },
+    "readme": "ERROR: No README data found!",
+    "scripts": {
+        "prepare": "presetter bootstrap",
+        "build": "run build",
+        "semantic-release": "semantic-release"
+    },
+    "dependencies": {
+        "@lumeweb/libkernel": "^0.1.0-develop.9",
+        "async-mutex": "^0.4.0",
+        "b4a": "^1.6.4"
+    },
+    "files": [
+        "lib/**"
+    ],
+    "publishConfig": {
+        "access": "public"
     }
 }

src/index.ts

@@ -1,94 +1,260 @@
-import {
-    callModule as callModuleKernel,
-    connectModule as connectModuleKernel,
-} from "libkernel";
-import {
-    callModule as callModuleModule,
-    connectModule as connectModuleModule,
-} from "libkmodule";
-import { EventEmitter } from "events";
-import { DataFn, ErrTuple } from "libskynet";
 import { Buffer } from "buffer";
+import { Client, factory } from "@lumeweb/libkernel/module";
+import { DataFn, ErrTuple, hexToBuf, logErr } from "@lumeweb/libkernel";
+import { blake2b } from "@noble/hashes/blake2b";
+import b4a from "b4a";
 
-const DHT_MODULE = "AQD1IgE4lTZkq1fqdoYGojKRNrSk0YQ_wrHbRtIiHDrnow";
+// @ts-ignore
+import Backoff from "backoff.js";
+import { Mutex } from "async-mutex";
+// @ts-ignore
+import Protomux from "protomux";
+import type { UnsubscribeFn } from "emittery";
 
-let callModule: typeof callModuleModule,
-    connectModule: typeof connectModuleModule;
+export class SwarmClient extends Client {
+  private useDefaultSwarm: boolean;
+  private id: number = 0;
+  private _autoReconnect: boolean;
+  private _connectBackoff: any;
 
-if (window.document) {
-    callModule = callModuleKernel;
-    connectModule = connectModuleKernel;
-} else {
-    callModule = callModuleModule;
-    connectModule = connectModuleModule;
+  private _ready?: Promise<void>;
+  private _connectionListener?: [
+    sendUpdate: DataFn,
+    response: Promise<ErrTuple>,
+  ];
+
+  private _topics: Set<Uint8Array> = new Set<Uint8Array>();
+  private _sockets: Map<number, Socket> = new Map<number, Socket>();
+
+  get dht() {
+    const self = this;
+    return {
+      async ready() {
+        return self.ready();
+      },
+    };
+  }
+
+  constructor(module: string, useDefaultDht = true, autoReconnect = false) {
+    super(module);
+    this.useDefaultSwarm = useDefaultDht;
+    this._autoReconnect = autoReconnect;
+    this._connectBackoff = new Backoff({
+      strategy: "fibo",
+      maxAttempts: Number.MAX_SAFE_INTEGER,
+    });
+
+    this._connectBackoff.on("retry", (error: any) => {
+      logErr(error);
+    });
+  }
+
+  get swarm(): number | undefined {
+    return this.useDefaultSwarm ? undefined : this.id;
+  }
+
+  public async connect(pubkey: string | Uint8Array): Promise<Socket> {
+    if (typeof pubkey === "string") {
+      const buf = hexToBuf(pubkey);
+      pubkey = this.handleErrorOrReturn(buf);
+    }
+
+    let existing = Array.from(this._sockets.values()).filter((socket) => {
+      return b4a.equals(socket.remotePublicKey, pubkey as Uint8Array);
+    });
+
+    if (existing.length) {
+      return existing[0] as Socket;
+    }
+
+    throw new Error("not implemented");
+  }
+
+  async init(): Promise<ErrTuple> {
+    return await this.callModuleReturn("init", { swarm: this.swarm });
+  }
+
+  async ready(): Promise<void> {
+    if (this._ready) {
+      return this._ready;
+    }
+
+    this._listen();
+
+    this._ready = this.callModuleReturn("ready", { swarm: this.swarm });
+
+    await this._ready;
+
+    this._ready = undefined;
+
+    for (const topic of this._topics) {
+      await this.join(topic);
+    }
+  }
+
+  async start(): Promise<void> {
+    await this._connectBackoff.run(() => this.init());
+
+    await this.ready();
+  }
+
+  private async _listen() {
+    if (!this._connectionListener) {
+      this._connectionListener = this.connectModule(
+        "listenConnections",
+        { swarm: this.swarm },
+        async (socketId: any) => {
+          const socket =
+            this._sockets.get(socketId) ?? (await createSocket(socketId, this));
+
+          socket.on("close", () => {
+            this._sockets.delete(socketId);
+          });
+
+          if (!this._sockets.has(socketId)) {
+            this._sockets.set(socketId, socket);
+          }
+
+          this.emit("connection", socket);
+        },
+      );
+    }
+
+    await this._connectionListener[1];
+    this._connectionListener = undefined;
+    this.start();
+  }
+
+  public async addRelay(pubkey: string): Promise<void> {
+    return this.callModuleReturn("addRelay", { pubkey, swarm: this.swarm });
+  }
+
+  public async removeRelay(pubkey: string): Promise<void> {
+    return this.callModuleReturn("removeRelay", { pubkey, swarm: this.swarm });
+  }
+
+  public async clearRelays(): Promise<void> {
+    return this.callModuleReturn("clearRelays", { swarm: this.swarm });
+  }
+
+  public async getRelays(): Promise<string[]> {
+    return this.callModuleReturn("getRelays", { swarm: this.swarm });
+  }
+
+  public async join(topic: Buffer | Uint8Array | string): Promise<void> {
+    if (typeof topic === "string") {
+      topic = blake2b(topic, { dkLen: 32 });
+    }
+
+    this._topics.add(topic);
+    this.callModule("join", { id: this.id, topic });
+  }
 }
 
-export class DHT {
-    public async connect(pubkey: string): Promise<Socket> {
-        const [resp, err] = await callModule(DHT_MODULE, "connect", { pubkey });
-        if (err) {
-            throw err;
-        }
-        return new Socket(resp.id);
-    }
-
-    async ready(): Promise<ErrTuple> {
-        return callModule(DHT_MODULE, "ready");
-    }
+interface SocketRawStream {
+  remoteHost: string;
+  remotePort: number;
+  remoteFamily: string;
 }
 
-export class Socket extends EventEmitter {
-    private id: number;
-    private eventUpdates: { [event: string]: DataFn[] } = {};
+export class Socket extends Client {
+  private id: number;
+  private eventUpdates: { [event: string]: DataFn[] } = {};
 
-    constructor(id: number) {
-        super();
-        this.id = id;
+  private syncMutex = new Mutex();
+
+  private swarm: SwarmClient;
+  private userData?: any = null;
+
+  constructor(module: string, id: number, swarm: SwarmClient) {
+    super(module);
+    this.id = id;
+    this.swarm = swarm;
+  }
+
+  private _remotePublicKey?: Uint8Array;
+
+  get remotePublicKey(): Uint8Array {
+    return this._remotePublicKey as Uint8Array;
+  }
+
+  private _rawStream?: Uint8Array;
+
+  get rawStream(): Uint8Array {
+    return this._rawStream as Uint8Array;
+  }
+
+  async setup() {
+    let info = await this.callModuleReturn("socketGetInfo", { id: this.id });
+
+    this._remotePublicKey = info.remotePublicKey;
+    this._rawStream = info.rawStream;
+    await this.swarm.emit("setup", this);
+  }
+
+  on(event: any, listener: any): UnsubscribeFn {
+    const [update, promise] = this.connectModule(
+      "socketListenEvent",
+      { id: this.id, event: event },
+      (data: any) => {
+        this.emit(event, data);
+      },
+    );
+    this.trackEvent(event as string, update);
+
+    promise.then(() => {
+      this.off(event as string, listener);
+    });
+
+    return super.on(event, listener);
+  }
+
+  off(event: any, listener: any): this {
+    const updates = [...this.eventUpdates[event as string]];
+    this.eventUpdates[event as string] = [];
+    for (const func of updates) {
+      func();
     }
+    super.off(event, listener);
+    return this;
+  }
 
-    on(eventName: string, listener: (...args: any[]) => void): this {
-        const [update, promise] = connectModule(
-            DHT_MODULE,
-            "listenSocketEvent",
-            { id: this.id, event: eventName },
-            (data: any) => {
-                this.emit(eventName, data);
-            }
-        );
-        this.trackEvent(eventName, update);
+  write(message: string | Buffer): void {
+    this.callModule("socketWrite", { id: this.id, message });
+  }
 
-        promise.then(() => {
-            this.off(eventName, listener);
-        });
-
-        return super.on(eventName, listener);
-    }
-
-    off(type: string, listener: any): this {
-        const updates = [...this.eventUpdates[type]];
-        this.eventUpdates[type] = [];
-        for (const func of updates) {
-            func({ action: "off" });
+  end(): void {
+    this.callModule("socketExists", { id: this.id }).then(
+      ([exists]: ErrTuple) => {
+        if (exists) {
+          this.callModule("socketClose", { id: this.id });
         }
-        return super.off(type, listener);
-    }
+      },
+    );
+  }
 
-    write(message: string | Buffer): void {
-        callModule(DHT_MODULE, "write", { id: this.id, message });
+  private ensureEvent(event: string): void {
+    if (!(event in this.eventUpdates)) {
+      this.eventUpdates[event] = [];
     }
+  }
 
-    end(): void {
-        callModule(DHT_MODULE, "close", { id: this.id });
-    }
-
-    private ensureEvent(event: string): void {
-        if (!(event in this.eventUpdates)) {
-            this.eventUpdates[event] = [];
-        }
-    }
-
-    private trackEvent(event: string, update: DataFn): void {
-        this.ensureEvent(event as string);
-        this.eventUpdates[event].push(update);
-    }
+  private trackEvent(event: string, update: DataFn): void {
+    this.ensureEvent(event as string);
+    this.eventUpdates[event].push(update);
+  }
 }
+
+export const MODULE =
+  "zduSB7gEXpcHo4F1esrpHRaB9nYh6KtTn3bktnpJRxWnpvqPhaLNmPwAp7";
+
+export const createClient = factory<SwarmClient>(SwarmClient, MODULE);
+
+const socketFactory = factory<Socket>(Socket, MODULE);
+const createSocket = async (...args: any): Promise<Socket> => {
+  const socket = socketFactory(...args);
+
+  await socket.setup();
+
+  return socket;
+};

tsconfig.json

@@ -1,23 +0,0 @@
-{
-    "compilerOptions": {
-        "declaration": true,
-        "strict": true,
-        "module": "esnext",
-        "target": "esnext",
-        "esModuleInterop": true,
-        "sourceMap": false,
-        "rootDir": "src",
-        "outDir": "dist",
-        "typeRoots": [
-            "node_modules/@types",
-        ],
-        "moduleResolution": "node",
-        "declarationMap": true,
-        "declarationDir": "dist",
-        "emitDeclarationOnly": false,
-        "allowJs": true
-    },
-    "include": [
-        "src"
-    ]
-}