@holochain/hc-spin 0.300.0 → 0.300.2-dev.0

package/README.md

@@ -20,6 +20,14 @@ To install the latest version compatible with **holochain 0.2.x**:
 npm install --save-dev @holochain/hc-spin@">=0.200.0 <0.300.0"
 ```
 
+To install the latest version compatible with **holochain 0.3.x**:
+
+⚠️ Requires `@holochain/client 0.17.0-dev.5` or newer ⚠️
+
+```
+npm install --save-dev @holochain/hc-spin@">=0.300.0 <0.400.0"
+```
+
 ## Usage (holochain 0.2)
 
 ```

package/cli/cli.js

@@ -4,7 +4,11 @@ const path = require('path');
 const fs = require('fs');
 
 let electronBinary;
-let pathStr = '../node_modules/.bin/electron';
+let pathStr =
+  process.platform === 'win32'
+    ? '../node_modules/electron/dist/electron.exe'
+    : '../node_modules/.bin/electron';
+
 // recursively look for electron binary in node_modules folder
 for (let i = 0; i < 7; i++) {
   const maybeElectronBinary = path.resolve(__dirname, pathStr);

package/dist/cli.js

@@ -4,7 +4,11 @@ const path = require('path');
 const fs = require('fs');
 
 let electronBinary;
-let pathStr = '../node_modules/.bin/electron';
+let pathStr =
+  process.platform === 'win32'
+    ? '../node_modules/electron/dist/electron.exe'
+    : '../node_modules/.bin/electron';
+
 // recursively look for electron binary in node_modules folder
 for (let i = 0; i < 7; i++) {
   const maybeElectronBinary = path.resolve(__dirname, pathStr);

package/dist/main/index.js

@@ -95,7 +95,7 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
     icon = electron.nativeImage.createFromPath(iconPath);
   } else {
     try {
-      const iconResponse = await electron.net.fetch(`http://127.0.0.1:${uiSource.port}/icon.png`);
+      const iconResponse = await electron.net.fetch(`http://localhost:${uiSource.port}/icon.png`);
       if (iconResponse.status === 404 && agentNum === 1) {
         console.warn(
           "\n\n+++++ WARNING +++++\n[hc-spin] No icon.png found. It is recommended to put an icon.png file (1024x1024 pixel) in the root of your UI assets directory which can be used by the Holochain Launcher.\n+++++++++++++++++++\n\n"
@@ -131,9 +131,9 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
     happWindow.webContents.openDevTools();
   if (uiSource.type === "port") {
     try {
-      await electron.net.fetch(`http://127.0.0.1:${uiSource.port}/index.html`);
+      await electron.net.fetch(`http://localhost:${uiSource.port}/index.html`);
     } catch (e) {
-      console.error(`No index.html file found at http://127.0.0.1:${uiSource.port}/index.html`, e);
+      console.error(`No index.html file found at http://localhost:${uiSource.port}/index.html`, e);
       if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
         happWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
       } else {
@@ -142,7 +142,7 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
       happWindow.show();
       return happWindow;
     }
-    await happWindow.loadURL(`http://127.0.0.1:${uiSource.port}`);
+    await happWindow.loadURL(`http://localhost:${uiSource.port}`);
   } else if (uiSource.type === "path") {
     try {
       await happWindow.loadURL(`webhapp://webhappwindow/index.html`);
@@ -10609,15 +10609,61 @@ const SignalType = {
   App: "App",
   System: "System"
 };
+const ERROR_TYPE = "error";
+const DEFAULT_TIMEOUT = 6e4;
+const requesterTransformer = (requester, tag, transform = identityTransformer) => async (req, timeout2) => {
+  const transformedInput = await transform.input(req);
+  const input = { type: { [tag]: null }, data: transformedInput };
+  const response = await requester(input, timeout2);
+  const output = transform.output(response.data);
+  return output;
+};
+const identity = (x) => x;
+const identityTransformer = {
+  input: identity,
+  output: identity
+};
+class HolochainError extends Error {
+  constructor(name, message) {
+    super();
+    this.name = name;
+    this.message = message;
+  }
+}
+const catchError = (res) => {
+  if (ERROR_TYPE in res.type) {
+    const errorName = Object.keys(res.data.type)[0];
+    const error = new HolochainError(errorName, res.data.data);
+    return Promise.reject(error);
+  } else {
+    return Promise.resolve(res);
+  }
+};
+const promiseTimeout = (promise2, tag, ms) => {
+  let id;
+  const timeout2 = new Promise((_, reject) => {
+    id = setTimeout(() => reject(new Error(`Timed out in ${ms}ms: ${tag}`)), ms);
+  });
+  return new Promise((res, rej) => {
+    Promise.race([promise2, timeout2]).then((a) => {
+      clearTimeout(id);
+      return res(a);
+    }).catch((e) => {
+      return rej(e);
+    });
+  });
+};
 class WsClient extends Emittery {
   socket;
   url;
+  options;
   pendingRequests;
   index;
-  constructor(socket, url2) {
+  constructor(socket, url2, options) {
     super();
     this.socket = socket;
     this.url = url2;
+    this.options = options || {};
     this.pendingRequests = {};
     this.index = 0;
     this.setupSocket();
@@ -10631,14 +10677,14 @@ class WsClient extends Emittery {
         if (typeof Buffer !== "undefined" && Buffer.isBuffer(serializedMessage.data)) {
           deserializedData = serializedMessage.data;
         } else {
-          throw new Error("websocket client: unknown message format");
+          throw new HolochainError("UnknownMessageFormat", `incoming message has unknown message format - ${deserializedData}`);
         }
       }
       const message = msgpack.decode(deserializedData);
       assertHolochainMessage(message);
       if (message.type === "signal") {
         if (message.data === null) {
-          throw new Error("received a signal without data");
+          throw new HolochainError("UnknownSignalFormat", "incoming signal has no data");
         }
         const deserializedSignal = msgpack.decode(message.data);
         assertHolochainSignal(deserializedSignal);
@@ -10656,14 +10702,14 @@ class WsClient extends Emittery {
       } else if (message.type === "response") {
         this.handleResponse(message);
       } else {
-        console.error(`Got unrecognized Websocket message type: ${message.type}`);
+        throw new HolochainError("UnknownMessageType", `incoming message has unknown type - ${message.type}`);
       }
     };
     this.socket.onclose = (event) => {
       const pendingRequestIds = Object.keys(this.pendingRequests).map((id) => parseInt(id));
       if (pendingRequestIds.length) {
         pendingRequestIds.forEach((id) => {
-          const error = new Error(`Websocket closed with pending requests. Close event code: ${event.code}, request id: ${id}`);
+          const error = new HolochainError("ClientClosedWithPendingRequests", `client closed with pending requests - close event code: ${event.code}, request id: ${id}`);
           this.pendingRequests[id].reject(error);
           delete this.pendingRequests[id];
         });
@@ -10676,14 +10722,14 @@ class WsClient extends Emittery {
    * @param url - The WebSocket URL to connect to.
    * @returns An new instance of the WsClient.
    */
-  static connect(url2) {
+  static connect(url2, options) {
     return new Promise((resolve, reject) => {
-      const socket = new IsoWebSocket(url2);
-      socket.onerror = () => {
-        reject(new Error(`could not connect to holochain conductor, please check that a conductor service is running and available at ${url2}`));
+      const socket = new IsoWebSocket(url2, options);
+      socket.onerror = (errorEvent) => {
+        reject(new HolochainError("ConnectionError", `could not connect to Holochain Conductor API at ${url2} - ${errorEvent.error}`));
       };
       socket.onopen = () => {
-        const client = new WsClient(socket, url2);
+        const client = new WsClient(socket, url2, options);
         resolve(client);
       };
     });
@@ -10714,10 +10760,10 @@ class WsClient extends Emittery {
       return promise2;
     } else if (this.url) {
       const response = new Promise((resolve, reject) => {
-        const socket = new IsoWebSocket(this.url);
+        const socket = new IsoWebSocket(this.url, this.options);
         this.socket = socket;
-        socket.onerror = () => {
-          reject(new Error(`could not connect to Holochain conductor, please check that a conductor service is running and available at ${this.url}`));
+        socket.onerror = (errorEvent) => {
+          reject(new HolochainError("ConnectionError", `could not connect to Holochain Conductor API at ${this.url} - ${errorEvent.error}`));
         };
         socket.onopen = () => {
           this.sendMessage(request, resolve, reject);
@@ -10750,7 +10796,7 @@ class WsClient extends Emittery {
       }
       delete this.pendingRequests[id];
     } else {
-      console.error(`Got response with no matching request. id=${id}`);
+      console.error(`got response with no matching request. id = ${id} msg = ${msg}`);
     }
   }
   /**
@@ -10774,58 +10820,14 @@ function assertHolochainMessage(message) {
   if (typeof message === "object" && message !== null && "type" in message && "data" in message) {
     return;
   }
-  throw new Error(`unknown message format ${JSON.stringify(message, null, 4)}`);
+  throw new HolochainError("UnknownMessageFormat", `incoming message has unknown message format ${JSON.stringify(message, null, 4)}`);
 }
 function assertHolochainSignal(signal) {
   if (typeof signal === "object" && signal !== null && Object.values(SignalType).some((type) => type in signal)) {
     return;
   }
-  throw new Error(`unknown signal format ${JSON.stringify(signal, null, 4)}`);
+  throw new HolochainError("UnknownSignalFormat", `incoming signal has unknown signal format ${JSON.stringify(signal, null, 4)}`);
 }
-const ERROR_TYPE = "error";
-const DEFAULT_TIMEOUT = 6e4;
-const requesterTransformer = (requester, tag, transform = identityTransformer) => async (req, timeout2) => {
-  const transformedInput = await transform.input(req);
-  const input = { type: { [tag]: null }, data: transformedInput };
-  const response = await requester(input, timeout2);
-  const output = transform.output(response.data);
-  return output;
-};
-const identity = (x) => x;
-const identityTransformer = {
-  input: identity,
-  output: identity
-};
-class HolochainError extends Error {
-  constructor(name, message) {
-    super();
-    this.name = name;
-    this.message = message;
-  }
-}
-const catchError = (res) => {
-  if (ERROR_TYPE in res.type) {
-    const errorName = Object.keys(res.data.type)[0];
-    const error = new HolochainError(errorName, res.data.data);
-    return Promise.reject(error);
-  } else {
-    return Promise.resolve(res);
-  }
-};
-const promiseTimeout = (promise2, tag, ms) => {
-  let id;
-  const timeout2 = new Promise((_, reject) => {
-    id = setTimeout(() => reject(new Error(`Timed out in ${ms}ms: ${tag}`)), ms);
-  });
-  return new Promise((res, rej) => {
-    Promise.race([promise2, timeout2]).then((a) => {
-      clearTimeout(id);
-      return res(a);
-    }).catch((e) => {
-      return rej(e);
-    });
-  });
-};
 class AppWebsocket extends Emittery {
   client;
   defaultTimeout;
@@ -10845,17 +10847,19 @@ class AppWebsocket extends Emittery {
   /**
    * Instance factory for creating AppWebsockets.
    *
-   * @param url - The `ws://` URL of the App API to connect to.
-   * @param defaultTimeout - Timeout to default to for all operations.
+   * @param options - {@link (WebsocketConnectionOptions:interface)}
    * @returns A new instance of an AppWebsocket.
    */
-  static async connect(url2, defaultTimeout) {
+  static async connect(options = {}) {
     const env = getLauncherEnvironment();
     if (env?.APP_INTERFACE_PORT) {
-      url2 = new URL(`ws://127.0.0.1:${env.APP_INTERFACE_PORT}`);
+      options.url = new URL(`ws://127.0.0.1:${env.APP_INTERFACE_PORT}`);
+    }
+    if (!options.url) {
+      throw new HolochainError("ConnectionUrlMissing", `unable to connect to Conductor API - no url provided and not in a launcher environment.`);
     }
-    const wsClient = await WsClient.connect(url2);
-    const appWebsocket = new AppWebsocket(wsClient, defaultTimeout, env?.INSTALLED_APP_ID);
+    const wsClient = await WsClient.connect(options.url, options.wsClientOptions);
+    const appWebsocket = new AppWebsocket(wsClient, options.defaultTimeout, env?.INSTALLED_APP_ID);
     wsClient.on("signal", (signal) => appWebsocket.emit("signal", signal));
     return appWebsocket;
   }
@@ -10936,7 +10940,7 @@ const appInfoTransform = (appWs) => ({
 const signZomeCall = async (request) => {
   const signingCredentialsForCell = getSigningCredentials(request.cell_id);
   if (!signingCredentialsForCell) {
-    throw new Error(`cannot sign zome call: no signing credentials have been authorized for cell [${encodeHashToBase64(request.cell_id[0])}, ${encodeHashToBase64(request.cell_id[1])}]`);
+    throw new HolochainError("NoSigningCredentialsForCell", `no signing credentials have been authorized for cell [${encodeHashToBase64(request.cell_id[0])}, ${encodeHashToBase64(request.cell_id[1])}]`);
   }
   const unsignedZomeCallPayload = {
     cap_secret: signingCredentialsForCell.capSecret,
@@ -11803,8 +11807,10 @@ const menu = electron.Menu.buildFromTemplate([
   }
 ]);
 const rustUtils = require("@holochain/hc-spin-rust-utils");
+const cliPackageJsonPath = path.resolve(path.join(electron.app.getAppPath(), "../../package.json"));
+const cliPackageJson = require(cliPackageJsonPath);
 const cli = new commander.Command();
-cli.name("hc-spin").description("CLI to run Holochain aps during development.").version(`0.300.0 (for holochain 0.3.x)`).argument(
+cli.name("hc-spin").description("CLI to run Holochain aps during development.").version(`${cliPackageJson.version} (built for holochain ${cliPackageJson.holochainVersion})`).argument(
   "<path>",
   "Path to .webhapp or .happ file to launch. If a .happ file is passed, either a UI path must be specified via --ui-path or a port pointing to a localhost server via --ui-port"
 ).option(
@@ -12018,8 +12024,15 @@ electron.app.whenReady().then(async () => {
   for (var i = 0; i < CLI_OPTS.numAgents; i++) {
     const zomeCallSigner = await rustUtils.ZomeCallSigner.connect(lairUrls[i], "pass");
     const appPort = portsInfo[i].app_ports[0];
-    const appWs = await AppWebsocket.connect(new URL(`ws://127.0.0.1:${appPort}`));
+    const appWs = await AppWebsocket.connect({
+      url: new URL(`ws://127.0.0.1:${appPort}`),
+      wsClientOptions: {
+        origin: "hc-spin"
+      }
+    });
     const appInfo = await appWs.appInfo({ installed_app_id: CLI_OPTS.appId });
+    if (!appInfo)
+      throw new Error("AppInfo is null.");
     const happWindow = await createHappWindow(
       CLI_OPTS.uiSource,
       CLI_OPTS.happOrWebhappPath,

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@holochain/hc-spin",
-  "version": "0.300.0",
+  "version": "0.300.2-dev.0",
+  "holochainVersion": "0.3.0-beta-dev.44",
   "description": "CLI to run Holochain aps during development.",
   "author": "matthme",
   "homepage": "https://developer.holochain.org",
@@ -34,7 +35,7 @@
   "dependencies": {
     "@electron-toolkit/preload": "^3.0.0",
     "@electron-toolkit/utils": "^3.0.0",
-    "@holochain/client": "^0.17.0-dev.5",
+    "@holochain/client": "^0.17.0-dev.8",
     "@holochain/hc-spin-rust-utils": "^0.300.1",
     "@msgpack/msgpack": "^2.8.0",
     "commander": "11.1.0",

package/src/main/index.ts

@@ -23,12 +23,15 @@ import { menu } from './menu';
 
 const rustUtils = require('@holochain/hc-spin-rust-utils');
 
+const cliPackageJsonPath = path.resolve(path.join(app.getAppPath(), '../../package.json'));
+const cliPackageJson = require(cliPackageJsonPath);
+
 const cli = new Command();
 
 cli
   .name('hc-spin')
   .description('CLI to run Holochain aps during development.')
-  .version(`0.300.0 (for holochain 0.3.x)`)
+  .version(`${cliPackageJson.version} (built for holochain ${cliPackageJson.holochainVersion})`)
   .argument(
     '<path>',
     'Path to .webhapp or .happ file to launch. If a .happ file is passed, either a UI path must be specified via --ui-path or a port pointing to a localhost server via --ui-port',
@@ -327,8 +330,14 @@ app.whenReady().then(async () => {
     const zomeCallSigner = await rustUtils.ZomeCallSigner.connect(lairUrls[i], 'pass');
 
     const appPort = portsInfo[i].app_ports[0];
-    const appWs = await AppWebsocket.connect(new URL(`ws://127.0.0.1:${appPort}`));
+    const appWs = await AppWebsocket.connect({
+      url: new URL(`ws://127.0.0.1:${appPort}`),
+      wsClientOptions: {
+        origin: 'hc-spin',
+      },
+    });
     const appInfo = await appWs.appInfo({ installed_app_id: CLI_OPTS.appId });
+    if (!appInfo) throw new Error('AppInfo is null.');
     const happWindow = await createHappWindow(
       CLI_OPTS.uiSource,
       CLI_OPTS.happOrWebhappPath,

package/src/main/windows.ts

@@ -67,7 +67,7 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
     icon = nativeImage.createFromPath(iconPath);
   } else {
     try {
-      const iconResponse = await net.fetch(`http://127.0.0.1:${uiSource.port}/icon.png`);
+      const iconResponse = await net.fetch(`http://localhost:${uiSource.port}/icon.png`);
       if (iconResponse.status === 404 && agentNum === 1) {
         console.warn(
           '\n\n+++++ WARNING +++++\n[hc-spin] No icon.png found. It is recommended to put an icon.png file (1024x1024 pixel) in the root of your UI assets directory which can be used by the Holochain Launcher.\n+++++++++++++++++++\n\n',
@@ -110,9 +110,9 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
   if (uiSource.type === 'port') {
     try {
       // Check whether dev server is responsive and index.html exists
-      await net.fetch(`http://127.0.0.1:${uiSource.port}/index.html`);
+      await net.fetch(`http://localhost:${uiSource.port}/index.html`);
     } catch (e) {
-      console.error(`No index.html file found at http://127.0.0.1:${uiSource.port}/index.html`, e);
+      console.error(`No index.html file found at http://localhost:${uiSource.port}/index.html`, e);
       if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
         happWindow.loadURL(process.env['ELECTRON_RENDERER_URL']);
       } else {
@@ -121,7 +121,7 @@ electron.contextBridge.exposeInMainWorld("__HC_LAUNCHER_ENV__", {
       happWindow.show();
       return happWindow;
     }
-    await happWindow.loadURL(`http://127.0.0.1:${uiSource.port}`);
+    await happWindow.loadURL(`http://localhost:${uiSource.port}`);
   } else if (uiSource.type === 'path') {
     try {
       await happWindow.loadURL(`webhapp://webhappwindow/index.html`);