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

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

.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,9 @@
+{
+    "preset": [
+        "@lumeweb/presetter-kernel-module-preset"
+    ],
+    "config": {
+        "official": true,
+        "browser": true
+    }
+}

CHANGELOG.md

@@ -0,0 +1 @@
+## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/kernel-handshake-node/compare/v0.0.1...v0.0.2-develop.1) (2023-07-06)

README.md

@@ -1,2 +0,0 @@
-# kernel-handshake-node
-

package.json

@@ -0,0 +1,36 @@
+{
+    "name": "@lumeweb/kernel-handshake-node",
+    "types": "module",
+    "repository": {
+        "type": "git",
+        "url": "gitea@git.lumeweb.com:LumeWeb/kernel-handshake-node.git"
+    },
+    "author": {
+        "name": "Hammer Technologies LLC",
+        "email": "contact@lumeweb.com"
+    },
+    "type": "module",
+    "version": "0.0.2-develop.1",
+    "readme": "ERROR: No README data found!",
+    "scripts": {
+        "prepare": "presetter bootstrap",
+        "build": "shx echo 'export default undefined;' > nop.js; run build",
+        "semantic-release": "semantic-release"
+    },
+    "devDependencies": {
+        "@lumeweb/presetter-kernel-module-preset": "^0.1.0-develop.30",
+        "@rollup/plugin-alias": "^5.0.0",
+        "presetter": "*",
+        "rollup-plugin-ignore-import": "^1.3.2"
+    },
+    "dependencies": {
+        "@i2labs/dns": "^1.0.1",
+        "@lumeweb/kernel-swarm-client": "^0.0.2-develop.6",
+        "@lumeweb/libhyperproxy": "^0.0.2-develop.1",
+        "@lumeweb/libkernel": "^0.1.0-develop.14",
+        "assert": "^2.0.0",
+        "hsd": "^5.0.1",
+        "p-defer": "^4.0.0",
+        "timers-browserify": "^2.0.12"
+    }
+}

rollup.config.ts

@@ -0,0 +1,67 @@
+// @ts-nocheck
+import * as import0 from "@rollup/plugin-json";
+import * as import1 from "@rollup/plugin-node-resolve";
+import * as import2 from "@rollup/plugin-commonjs";
+import * as import3 from "@rollup/plugin-graphql";
+import * as import4 from "@rollup/plugin-image";
+import * as import5 from "@rollup/plugin-yaml";
+import * as import6 from "rollup-plugin-postcss";
+import * as import7 from "rollup-plugin-visualizer";
+import * as import8 from "@rollup/plugin-wasm";
+import * as import9 from "@rollup/plugin-alias";
+import * as import10 from "rollup-plugin-ignore-import";
+export default {
+  input: "build/index.js",
+  output: [
+    {
+      file: "lib/index.js",
+      format: "cjs",
+      sourcemap: true,
+      inlineDynamicImports: true,
+    },
+  ],
+  plugins: [
+    import0.default(...([] as const)),
+    import10.default({
+      include: [
+        "**/multiSocket/tcpSocket.js",
+        "**/node-fetch/**",
+        "**/urkel/lib/file.js",
+      ],
+      exclude: [],
+    }),
+    import9.default({
+      entries: {
+        timers: "timers-browserify",
+        stream: "./nop.js",
+        blgr: "blgr/lib/fs-browser.js",
+      },
+    }),
+    import1.default(
+      ...([
+        {
+          browser: true,
+          preferBuiltins: false,
+          dedupe: [
+            "@lumeweb/libkernel",
+            "@lumeweb/libweb",
+            "@lumeweb/libportal",
+          ],
+        },
+      ] as const),
+    ),
+    import2.default(
+      ...([{ extensions: [".js", ".jsx", ".ts", ".tsx"] }] as const),
+    ),
+    import10.default({
+      include: [/.*commonjs-external/],
+      exclude: [],
+    }),
+    import3.default(...([] as const)),
+    import4.default(...([] as const)),
+    import5.default(...([] as const)),
+    import6.default(...([{ inject: { insertAt: "top" } }] as const)),
+    import7.visualizer(...([] as const)),
+    import8.default(...([{ targetEnv: "auto-inline" }] as const)),
+  ],
+};

src/index.ts

@@ -0,0 +1,190 @@
+import type { ActiveQuery } from "@lumeweb/libkernel/module";
+import { addHandler, handleMessage } from "@lumeweb/libkernel/module";
+import { createClient } from "@lumeweb/kernel-swarm-client";
+import {
+  createServer,
+  DummySocket,
+  MultiSocketProxy,
+} from "@lumeweb/libhyperproxy";
+// @ts-ignore
+import { SPVNode } from "hsd/lib/node";
+import defer from "p-defer";
+import dns from "@i2labs/dns";
+import assert from "assert";
+
+const PROTOCOL = "lumeweb.proxy.handshake";
+
+onmessage = handleMessage;
+
+let moduleLoadedResolve: Function;
+let moduleLoaded: Promise<void> = new Promise((resolve) => {
+  moduleLoadedResolve = resolve;
+});
+
+addHandler("presentKey", handlePresentKey);
+addHandler("ready", handleReady);
+addHandler("query", handleQuery);
+
+let swarm;
+let proxy: MultiSocketProxy;
+let node: SPVNode;
+
+function resolveWithPeers(resolve: Function) {
+  if (!node.pool.peers.head()) {
+    node.pool.on("peer", () => {
+      resolveWithPeers(resolve);
+    });
+    return;
+  }
+
+  let syncable = false;
+
+  for (let peer = node.pool.peers.head(); peer; peer = peer.next) {
+    if (node.pool.isSyncable(peer)) {
+      syncable = true;
+      break;
+    }
+  }
+
+  if (!syncable) {
+    for (let peer = node.pool.peers.head(); peer; peer = peer.next) {
+      const listener = () => {
+        peer.off("open", listener);
+        resolve();
+      };
+      peer.on("open", listener);
+    }
+    return;
+  }
+
+  return resolve(null);
+}
+
+async function handlePresentKey(aq: ActiveQuery) {
+  swarm = createClient();
+
+  const peerConnected = defer();
+  node = new SPVNode({
+    config: false,
+    argv: false,
+    env: false,
+    noDns: true,
+    memory: false,
+    logFile: false,
+    logConsole: true,
+    logLevel: "info",
+    workers: true,
+    network: "main",
+    createServer,
+    createSocket: (port: number, host: string) => {
+      const socket = proxy.createSocket({
+        host,
+        port,
+      }) as unknown as DummySocket;
+      socket.connect();
+
+      return socket;
+    },
+  });
+
+  node.pool.hosts.resolve = async (host: any, family?: any) => {
+    if (family == null) family = null;
+
+    assert(family === null || family === 4 || family === 6);
+
+    const stub = new dns.promises.Resolver();
+
+    stub.setServers([
+      // Cloudflare
+      "1.1.1.1",
+      // Google
+      "8.8.8.8",
+      "8.8.4.4",
+      // OpenDNS
+      "208.67.222.222",
+      "208.67.220.220",
+      "208.67.222.220",
+      "208.67.220.222",
+    ]);
+
+    const out: string[] = [];
+    const types: string[] = [];
+
+    if (family == null || family === 4) types.push("A");
+
+    if (family == null || family === 6) types.push("AAAA");
+
+    for (const type of types) {
+      let addrs;
+
+      try {
+        addrs = await stub.resolve(host, type as any);
+      } catch (e) {
+        continue;
+      }
+
+      // @ts-ignore
+      out.push(...addrs);
+    }
+
+    if (out.length === 0) throw new Error("No DNS results.");
+
+    return out;
+  };
+
+  if (node?.http?.http?.listen) {
+    node.http.http.listen = (port: number, host: string, cb: Function) => cb();
+  }
+
+  proxy = new MultiSocketProxy({
+    protocol: PROTOCOL,
+    swarm,
+    server: false,
+    autostart: true,
+    listen: true,
+  });
+
+  proxy.on("peerChannelOpen", () => {
+    peerConnected.resolve();
+  });
+
+  swarm.join(PROTOCOL);
+  await swarm.start();
+
+  await peerConnected.promise;
+
+  await node.open();
+  await node.connect();
+  await node.startSync();
+
+  moduleLoadedResolve();
+}
+
+async function handleReady(aq: ActiveQuery) {
+  await moduleLoaded;
+
+  await new Promise((resolve): void => {
+    if (node.chain.synced) {
+      return resolveWithPeers(resolve);
+    }
+
+    node.pool.once("full", () => {
+      resolveWithPeers(resolve);
+    });
+  });
+
+  aq.respond();
+}
+
+async function handleQuery(aq: ActiveQuery) {
+  if (!node.chain.synced || !node.pool.peers.head()) {
+    aq.reject("not ready");
+    return;
+  }
+
+  try {
+    aq.respond(await node.rpc.call(aq.callerInput));
+  } catch (e) {
+    aq.reject((e as Error).message);
+  }
+}