@holochain/hc-spin 0.200.0

package/rust-utils/src/decode_webhapp.rs

@@ -0,0 +1,112 @@
+use holochain_types::web_app::WebAppBundle;
+use std::fs;
+use std::path::PathBuf;
+
+#[napi]
+pub async fn save_happ_or_webhapp(
+    happ_or_web_happ_path: String,
+    app_id: String,
+    uis_dir: String,
+    happs_dir: String,
+) -> napi::Result<()> {
+    let happ_or_webhapp_bytes = fs::read(happ_or_web_happ_path)?;
+
+    let app_bundle = match WebAppBundle::decode(&happ_or_webhapp_bytes) {
+        Ok(web_app_bundle) => {
+            // extracting ui.zip bytes
+            let web_ui_zip_bytes = web_app_bundle.web_ui_zip_bytes().await.map_err(|e| {
+                napi::Error::from_reason(format!("Failed to extract ui zip bytes: {}", e))
+            })?;
+
+            let ui_target_dir = PathBuf::from(uis_dir);
+            if !path_exists(&ui_target_dir) {
+                fs::create_dir_all(&ui_target_dir)?;
+            }
+
+            let ui_zip_path = PathBuf::from(ui_target_dir.clone()).join("ui.zip");
+
+            // unzip and store UI
+            fs::write(
+                ui_zip_path.clone(),
+                web_ui_zip_bytes.into_owned().into_inner(),
+            )
+            .map_err(|e| {
+                napi::Error::from_reason(format!("Failed to write Web UI Zip file: {}", e))
+            })?;
+
+            let file = fs::File::open(ui_zip_path.clone()).map_err(|e| {
+                napi::Error::from_reason(format!("Failed to read Web UI Zip file: {}", e))
+            })?;
+
+            unzip_file(file, ui_target_dir.into())
+                .map_err(|e| napi::Error::from_reason(format!("Failed to unzip ui.zip: {}", e)))?;
+
+            fs::remove_file(ui_zip_path).map_err(|e| {
+                napi::Error::from_reason(format!("Failed to remove ui.zip after unzipping: {}", e))
+            })?;
+
+            // extracting happ bundle
+            let app_bundle = web_app_bundle.happ_bundle().await.map_err(|e| {
+                napi::Error::from_reason(format!(
+                    "Failed to get happ bundle from webapp bundle bytes: {}",
+                    e
+                ))
+            })?;
+
+            app_bundle
+        }
+        Err(e) => {
+            return Err(napi::Error::from_reason(format!(
+                "Failed to decode .webhapp file: {}",
+                e
+            )))
+        }
+    };
+
+    let happs_dir = PathBuf::from(happs_dir);
+    if !path_exists(&happs_dir) {
+        fs::create_dir_all(&happs_dir)?;
+    }
+
+    let happ_path = happs_dir.join(format!("{}.happ", app_id));
+
+    app_bundle
+        .write_to_file(&happ_path)
+        .await
+        .map_err(|e| napi::Error::from_reason(format!("Failed to write .happ file: {}", e)))?;
+
+    Ok(())
+}
+
+pub fn path_exists(path: &PathBuf) -> bool {
+    std::path::Path::new(path).exists()
+}
+
+pub fn unzip_file(reader: fs::File, outpath: PathBuf) -> Result<(), String> {
+    let mut archive = match zip::ZipArchive::new(reader) {
+        Ok(a) => a,
+        Err(e) => return Err(format!("Failed to unpack zip archive: {}", e)),
+    };
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i).unwrap();
+        let outpath = match file.enclosed_name() {
+            Some(path) => outpath.join(path).to_owned(),
+            None => continue,
+        };
+
+        if (&*file.name()).ends_with('/') {
+            fs::create_dir_all(&outpath).unwrap();
+        } else {
+            if let Some(p) = outpath.parent() {
+                if !p.exists() {
+                    fs::create_dir_all(&p).unwrap();
+                }
+            }
+            let mut outfile = fs::File::create(&outpath).unwrap();
+            std::io::copy(&mut file, &mut outfile).unwrap();
+        }
+    }
+
+    Ok(())
+}

package/rust-utils/src/lib.rs

@@ -0,0 +1,7 @@
+#[macro_use]
+extern crate napi_derive;
+
+pub mod decode_webhapp;
+pub mod types;
+mod utils;
+pub mod zome_call_signer;

package/rust-utils/src/types.rs

@@ -0,0 +1,52 @@
+use crate::utils::*;
+use holo_hash::{AgentPubKey, DnaHash};
+use holochain_integrity_types::{FunctionName, ZomeName};
+use holochain_zome_types::CellId;
+use holochain_zome_types::{CapSecret, ExternIO, ZomeCallUnsigned};
+use kitsune_p2p_timestamp::Timestamp;
+
+#[derive(Clone)]
+#[napi(object)]
+pub struct ZomeCallUnsignedNapi {
+    pub cell_id: Vec<Vec<u8>>,
+    pub zome_name: String,
+    pub fn_name: String,
+    pub payload: Vec<u8>,
+    pub cap_secret: Option<Vec<u8>>,
+    pub provenance: Vec<u8>,
+    pub nonce: Vec<u8>,
+    pub expires_at: i64,
+}
+
+impl Into<ZomeCallUnsigned> for ZomeCallUnsignedNapi {
+    fn into(self: Self) -> ZomeCallUnsigned {
+        ZomeCallUnsigned {
+            cell_id: CellId::new(
+                DnaHash::from_raw_39(self.cell_id.get(0).unwrap().clone()).unwrap(),
+                AgentPubKey::from_raw_39(self.cell_id.get(1).unwrap().clone()).unwrap(),
+            ),
+            zome_name: ZomeName::from(self.zome_name),
+            fn_name: FunctionName::from(self.fn_name),
+            payload: ExternIO::from(self.payload),
+            cap_secret: self
+                .cap_secret
+                .map_or(None, |c| Some(CapSecret::from(vec_to_arr(c)))),
+            provenance: AgentPubKey::from_raw_39(self.provenance).unwrap(),
+            nonce: vec_to_arr(self.nonce).into(),
+            expires_at: Timestamp(self.expires_at),
+        }
+    }
+}
+
+#[napi(object)]
+pub struct ZomeCallNapi {
+    pub cell_id: Vec<Vec<u8>>,
+    pub zome_name: String,
+    pub fn_name: String,
+    pub payload: Vec<u8>,
+    pub cap_secret: Option<Vec<u8>>,
+    pub provenance: Vec<u8>,
+    pub nonce: Vec<u8>,
+    pub expires_at: i64,
+    pub signature: Vec<u8>,
+}

package/rust-utils/src/utils.rs

@@ -0,0 +1,4 @@
+pub fn vec_to_arr<T, const N: usize>(v: Vec<T>) -> [T; N] {
+    v.try_into()
+        .unwrap_or_else(|v: Vec<T>| panic!("Expected a Vec of length {} but it was {}", N, v.len()))
+}

package/rust-utils/src/zome_call_signer.rs

@@ -0,0 +1,99 @@
+#![deny(clippy::all)]
+
+use std::ops::Deref;
+
+use holochain_zome_types::{Signature, ZomeCallUnsigned};
+use lair_keystore_api::{dependencies::url::Url, ipc_keystore::ipc_keystore_connect, LairClient};
+use napi::Result;
+use sodoken::BufRead;
+
+use crate::types::*;
+
+struct ZomeCallSigner {
+    lair_client: LairClient,
+}
+
+impl ZomeCallSigner {
+    /// Connect to lair keystore
+    pub async fn new(connection_url: String, passphrase: String) -> Self {
+        let connection_url_parsed = Url::parse(connection_url.deref()).unwrap();
+        let passphrase_bufread: BufRead = passphrase.as_bytes().into();
+
+        let lair_client = ipc_keystore_connect(connection_url_parsed, passphrase_bufread)
+            .await
+            .unwrap();
+
+        Self { lair_client }
+    }
+
+    /// Sign a zome call
+    pub async fn sign_zome_call(
+        &self,
+        zome_call_unsigned_js: ZomeCallUnsignedNapi,
+    ) -> Result<ZomeCallNapi> {
+        let zome_call_unsigned: ZomeCallUnsigned = zome_call_unsigned_js.clone().into();
+        let pub_key = zome_call_unsigned.provenance.clone();
+        let mut pub_key_2 = [0; 32];
+        pub_key_2.copy_from_slice(pub_key.get_raw_32());
+
+        let data_to_sign = zome_call_unsigned.data_to_sign().unwrap();
+
+        let sig = self
+            .lair_client
+            .sign_by_pub_key(pub_key_2.into(), None, data_to_sign)
+            .await
+            .unwrap();
+
+        let signature = Signature(*sig.0);
+
+        let signed_zome_call = ZomeCallNapi {
+            cell_id: zome_call_unsigned_js.cell_id,
+            zome_name: zome_call_unsigned.zome_name.to_string(),
+            fn_name: zome_call_unsigned.fn_name.0,
+            payload: zome_call_unsigned_js.payload,
+            cap_secret: zome_call_unsigned_js.cap_secret,
+            provenance: zome_call_unsigned_js.provenance,
+            nonce: zome_call_unsigned_js.nonce,
+            expires_at: zome_call_unsigned_js.expires_at,
+            signature: signature.0.to_vec(),
+        };
+
+        Ok(signed_zome_call)
+    }
+}
+
+#[napi(js_name = "ZomeCallSigner")]
+pub struct JsZomeCallSigner {
+    zome_call_signer: Option<ZomeCallSigner>,
+}
+
+#[napi]
+impl JsZomeCallSigner {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            zome_call_signer: None,
+        }
+    }
+
+    #[napi]
+    pub async fn connect(connection_url: String, passphrase: String) -> Self {
+        let zome_call_signer = ZomeCallSigner::new(connection_url, passphrase).await;
+
+        JsZomeCallSigner {
+            zome_call_signer: Some(zome_call_signer),
+        }
+    }
+
+    #[napi]
+    pub async fn sign_zome_call(
+        &self,
+        zome_call_unsigned_js: ZomeCallUnsignedNapi,
+    ) -> Result<ZomeCallNapi> {
+        self.zome_call_signer
+            .as_ref()
+            .unwrap()
+            .sign_zome_call(zome_call_unsigned_js)
+            .await
+    }
+}

package/src/main/index.ts

@@ -0,0 +1,305 @@
+import { app, IpcMainInvokeEvent, ipcMain, protocol } from 'electron';
+import fs from 'fs';
+import path from 'path';
+import { nanoid } from 'nanoid';
+import { Command, Option } from 'commander';
+import contextMenu from 'electron-context-menu';
+import split from 'split';
+import * as childProcess from 'child_process';
+import { ZomeCallSigner, ZomeCallUnsignedNapi } from 'hc-spin-rust-utils';
+import { createHappWindow } from './windows';
+import getPort from 'get-port';
+import { AgentPubKey, AppWebsocket } from '@holochain/client';
+import { validateCliArgs } from './validateArgs';
+
+const rustUtils = require('hc-spin-rust-utils');
+
+const cli = new Command();
+
+cli
+  .name('hc-spin')
+  .description('CLI to run Holochain aps during development.')
+  .version(`${app.getVersion()} (for holochain 0.2.x)`)
+  .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(
+    '--app-id <string>',
+    'Install the app with a specific app id. By default the app id is derived from the name of the .webhapp/.happ file that you pass but this option allows you to set it explicitly',
+  )
+  .option(
+    '--bootstrap-url <url>',
+    'Url of the bootstrap server to use. By default, hc spin spins up a local development bootstrap server for you but this argument allows you to specify a custom one.',
+  )
+  .option('--holochain-path <path>', 'Set the path to the holochain binary [default: holochain].')
+  .addOption(
+    new Option('-n, --num-agents <number>', 'How many agents to spawn the app for.').argParser(
+      parseInt,
+    ),
+  )
+  .option('--network-seed <string>', 'Install the app with a specific network seed.')
+  .option('--ui-path <path>', "Path to the folder containing the index.html of the webhapp's UI.")
+  .option(
+    '--ui-port <number>',
+    'Port pointing to a localhost dev server that serves your UI assets.',
+  )
+  .option(
+    '--signaling-url <url>',
+    'Url of the signaling server to use. By default, hc spin spins up a local development signaling server for you but this argument allows you to specify a custom one.',
+  );
+
+cli.parse();
+// console.log('Got CLI opts: ', cli.opts());
+// console.log('Got CLI args: ', cli.args);
+
+// Garbage collect unused directories of previous runs
+const files = fs.readdirSync(app.getPath('temp'));
+const hcSpinFolders = files.filter((file) => file.startsWith(`hc-spin-`));
+for (const folder of hcSpinFolders) {
+  const folderPath = path.join(app.getPath('temp'), folder);
+  const folderFiles = fs.readdirSync(folderPath);
+  if (folderFiles.includes('.abandoned')) {
+    fs.rmSync(folderPath, { recursive: true, force: true, maxRetries: 4 });
+  }
+}
+
+// Set app path to temp directory
+const DATA_ROOT_DIR = path.join(app.getPath('temp'), `hc-spin-${nanoid(8)}`);
+
+app.setPath('userData', path.join(DATA_ROOT_DIR, 'electron'));
+
+const CLI_OPTS = validateCliArgs(cli.args, cli.opts(), DATA_ROOT_DIR);
+
+// const SANDBOX_DIRECTORIES: Array<string> = [];
+const SANDBOX_PROCESSES: childProcess.ChildProcessWithoutNullStreams[] = [];
+const WINDOW_INFO_MAP: Record<
+  string,
+  { agentPubKey: AgentPubKey; zomeCallSigner: ZomeCallSigner }
+> = {};
+
+protocol.registerSchemesAsPrivileged([
+  {
+    scheme: 'webhapp',
+    privileges: { standard: true },
+  },
+]);
+
+contextMenu({
+  showSaveImageAs: true,
+  showSearchWithGoogle: false,
+  showInspectElement: true,
+});
+
+const handleSignZomeCall = (e: IpcMainInvokeEvent, zomeCall: ZomeCallUnsignedNapi) => {
+  const windowInfo = WINDOW_INFO_MAP[e.sender.id];
+  if (zomeCall.provenance.toString() !== Array.from(windowInfo.agentPubKey).toString())
+    return Promise.reject('Agent public key unauthorized.');
+  return windowInfo.zomeCallSigner.signZomeCall(zomeCall);
+};
+
+async function startLocalServices(): Promise<[string, string]> {
+  const localServicesHandle = childProcess.spawn('hc', ['run-local-services']);
+  return new Promise((resolve) => {
+    let bootStrapUrl;
+    let signalUrl;
+    let bootstrapRunning = false;
+    let signalRunnig = false;
+    localServicesHandle.stdout.pipe(split()).on('data', async (line: string) => {
+      console.log(`[hc-spin] | [hc run-local-services]: ${line}`);
+      if (line.includes('HC BOOTSTRAP - ADDR:')) {
+        bootStrapUrl = line.split('# HC BOOTSTRAP - ADDR:')[1].trim();
+      }
+      if (line.includes('HC SIGNAL - ADDR:')) {
+        signalUrl = line.split('# HC SIGNAL - ADDR:')[1].trim();
+      }
+      if (line.includes('HC BOOTSTRAP - RUNNING')) {
+        bootstrapRunning = true;
+      }
+      if (line.includes('HC SIGNAL - RUNNING')) {
+        signalRunnig = true;
+      }
+      if (bootstrapRunning && signalRunnig) resolve([bootStrapUrl, signalUrl]);
+    });
+    localServicesHandle.stderr.pipe(split()).on('data', async (line: string) => {
+      console.log(`[hc-spin] | [hc run-local-services] ERROR: ${line}`);
+    });
+  });
+}
+
+type PortsInfo = {
+  admin_port: number;
+  app_ports: number[];
+};
+
+async function spawnSandboxes(
+  nAgents: number,
+  happPath: string,
+  bootStrapUrl: string,
+  signalUrl: string,
+  appId: string,
+  networkSeed?: string,
+): Promise<
+  [childProcess.ChildProcessWithoutNullStreams, Array<string>, Record<number, PortsInfo>]
+> {
+  const generateArgs = [
+    'sandbox',
+    '--piped',
+    'generate',
+    '--num-sandboxes',
+    nAgents.toString(),
+    '--app-id',
+    appId,
+    '--run',
+  ];
+  let appPorts = '';
+  for (var i = 1; i <= nAgents; i++) {
+    const appPort = await getPort();
+    appPorts += `${appPort},`;
+  }
+  generateArgs.push(appPorts.slice(0, appPorts.length - 1));
+
+  if (networkSeed) {
+    generateArgs.push('--network-seed');
+    generateArgs.push(networkSeed);
+  }
+  generateArgs.push(happPath, 'network', '--bootstrap', bootStrapUrl, 'webrtc', signalUrl);
+  // console.log('GENERATE ARGS: ', generateArgs);
+
+  let readyConductors = 0;
+  const portsInfo: Record<number, PortsInfo> = {};
+  const sandboxPaths: Array<string> = [];
+  const lairUrls: string[] = [];
+
+  const sandboxHandle = childProcess.spawn('hc', generateArgs);
+  sandboxHandle.stdin.write('pass');
+  sandboxHandle.stdin.end();
+  return new Promise((resolve) => {
+    sandboxHandle.stdout.pipe(split()).on('data', async (line: string) => {
+      console.log(`[hc-spin] | [hc sandbox]: ${line}`);
+      if (line.includes('Created directory at:')) {
+        // hc-sandbox: Created directory at: /tmp/v7cLY7ls3onZFMmyrFi5y Keep this path to rerun the same sandbox. It has also been saved to a file called `.hc` in your current working directory.
+        const sanboxPath = line
+          .split('\x1B[1;4;48;5;254;38;5;4m')[1]
+          .split('\x1B[0m \x1B[1m')[0]
+          .trim();
+
+        sandboxPaths.push(sanboxPath);
+      }
+      if (line.includes('lair-keystore connection_url')) {
+        const lairKeystoreUrl = line.split('#')[2].trim();
+        lairUrls.push(lairKeystoreUrl);
+      }
+      if (line.includes('Conductor launched')) {
+        // hc-sandbox: Conductor launched #!1 {"admin_port":37045,"app_ports":[]}
+        const split1 = line.split('{');
+        const ports: PortsInfo = JSON.parse(`{${split1[1]}`);
+        const conductorNum = split1[0].split('#!')[1].trim();
+        portsInfo[conductorNum] = ports;
+        // hc-sandbox: Conductor launched #!1 {"admin_port":32805,"app_ports":[45309]}
+        readyConductors += 1;
+        if (readyConductors === nAgents) resolve([sandboxHandle, sandboxPaths, portsInfo]);
+      }
+    });
+    sandboxHandle.stderr.pipe(split()).on('data', async (line: string) => {
+      console.log(`[hc-spin] | [hc sandbox] ERROR: ${line}`);
+    });
+  });
+}
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.whenReady().then(async () => {
+  ipcMain.handle('sign-zome-call', handleSignZomeCall);
+
+  let happTargetDir: string | undefined;
+  // TODO unpack assets to UI dir if webhapp is passed
+  if (CLI_OPTS.happOrWebhappPath.type === 'webhapp') {
+    happTargetDir = path.join(DATA_ROOT_DIR, 'apps', CLI_OPTS.appId);
+    const uiTargetDir = path.join(happTargetDir, 'ui');
+    await rustUtils.saveHappOrWebhapp(
+      CLI_OPTS.happOrWebhappPath.path,
+      CLI_OPTS.appId,
+      uiTargetDir,
+      happTargetDir,
+    );
+  }
+
+  const [bootstrapUrl, signalingUrl] = await startLocalServices();
+
+  const [sandboxHandle, sandboxPaths, portsInfo] = await spawnSandboxes(
+    CLI_OPTS.numAgents,
+    happTargetDir ? happTargetDir : CLI_OPTS.happOrWebhappPath.path,
+    CLI_OPTS.bootstrapUrl ? CLI_OPTS.bootstrapUrl : bootstrapUrl,
+    CLI_OPTS.singalingUrl ? CLI_OPTS.singalingUrl : signalingUrl,
+    CLI_OPTS.appId,
+  );
+
+  const lairUrls: string[] = [];
+  sandboxPaths.forEach((sandbox) => {
+    const conductorConfigPath = path.join(sandbox, 'conductor-config.yaml');
+    const configStr = fs.readFileSync(conductorConfigPath, 'utf-8');
+    const lines = configStr.split('\n');
+    for (const line of lines) {
+      if (line.includes('connection_url')) {
+        //   connection_url: unix:///tmp/NgYtyB9jdYSC6BlmNTyra/keystore/socket?k=c-B-bRZIObKsh9c5q899hWjAWsWT28DNQUSElAFLJic
+        const lairUrl = line.split('connection_url:')[1].trim();
+        lairUrls.push(lairUrl);
+        // console.log('Got lairUrl form conductor-config.yaml: ', lairUrl);
+        break;
+      }
+    }
+  });
+
+  SANDBOX_PROCESSES.push(sandboxHandle);
+
+  // console.log('Got CLI_OPTS: ', CLI_OPTS);
+
+  // open browser window for each sandbox
+  //
+  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 appInfo = await appWs.appInfo({ installed_app_id: CLI_OPTS.appId });
+    const happWindow = await createHappWindow(
+      CLI_OPTS.uiSource,
+      CLI_OPTS.happOrWebhappPath,
+      CLI_OPTS.appId,
+      i + 1,
+      appPort,
+      DATA_ROOT_DIR,
+    );
+    WINDOW_INFO_MAP[happWindow.webContents.id] = {
+      agentPubKey: appInfo.agent_pub_key,
+      zomeCallSigner,
+    };
+  }
+
+  // app.on('activate', function () {
+  //   // On macOS it's common to re-create a window in the app when the
+  //   // dock icon is clicked and there are no other windows open.
+  //   if (BrowserWindow.getAllWindows().length === 0) createWindow();
+  // });
+});
+
+// Quit when all windows are closed, except on macOS. There, it's common
+// for applications and their menu bar to stay active until the user quits
+// explicitly with Cmd + Q.
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('quit', () => {
+  fs.writeFileSync(
+    path.join(DATA_ROOT_DIR, '.abandoned'),
+    "I'm not in use anymore by an active hc-spin process.",
+  );
+  // clean up sandboxes
+  SANDBOX_PROCESSES.forEach((handle) => handle.kill());
+  childProcess.spawnSync('hc', ['sandbox', 'clean']);
+});

package/src/main/validateArgs.ts

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { UISource } from './windows';
+
+export type CliOpts = {
+  appId?: string;
+  holochainPath?: string;
+  numAgents?: number;
+  networkSeed?: string;
+  uiPath?: string;
+  uiPort?: number;
+  signalingUrl?: string;
+  bootstrapUrl?: string;
+};
+
+export type CliOptsValidated = {
+  appId: string;
+  holochainPath: string | undefined;
+  numAgents: number;
+  networkSeed: string | undefined;
+  uiSource: UISource;
+  singalingUrl: string | undefined;
+  bootstrapUrl: string | undefined;
+  happOrWebhappPath: HappOrWebhappPath;
+};
+
+export type HappOrWebhappPath = {
+  type: 'happ' | 'webhapp';
+  path: string;
+};
+
+export function validateCliArgs(
+  cliArgs: string[],
+  cliOpts: CliOpts,
+  appDataRootDir: string,
+): CliOptsValidated {
+  if (cliArgs.length !== 1) {
+    throw new Error(
+      `hc spin takes exactly one argument (the path to the .happ or .webhapp file) but got ${cliArgs.length} arguments: ${cliArgs}`,
+    );
+  }
+  const happOrWebhappPath = cliArgs[0];
+  if (!happOrWebhappPath.endsWith('.happ') && !happOrWebhappPath.endsWith('.webhapp')) {
+    throw new Error(
+      `The path passed to hc spin must either be a .happ or a .webhapp file but got path '${happOrWebhappPath}'`,
+    );
+  }
+  if (!fs.existsSync(happOrWebhappPath)) {
+    throw new Error(
+      `Path to .happ or .webhapp file passed as argument does not exist: ${happOrWebhappPath}`,
+    );
+  }
+  if (cliOpts.numAgents && typeof cliOpts.numAgents !== 'number') {
+    throw new Error(
+      `The --num-agents (-n) option must be of type number but got: ${cliOpts.numAgents}`,
+    );
+  }
+  const isHapp = happOrWebhappPath.endsWith('.happ');
+  if (isHapp && !cliOpts.uiPath && !cliOpts.uiPort) {
+    throw new Error(
+      'If you pass a .happ file as argument, you must also provide either the --ui-port or the --ui-path option pointing to the UI assets.',
+    );
+  }
+  if (cliOpts.uiPath && cliOpts.uiPort) {
+    throw new Error(
+      'Only one of --ui-port and --ui-path is allowed at the same time but got values for both.',
+    );
+  }
+
+  const appId = cliOpts.appId ? cliOpts.appId : path.parse(path.basename(cliArgs[0])).name;
+  const holochainPath = cliOpts.holochainPath;
+  const numAgents = cliOpts.numAgents ? cliOpts.numAgents : 2;
+
+  return {
+    appId,
+    holochainPath,
+    numAgents,
+    networkSeed: cliOpts.networkSeed,
+    uiSource: cliOpts.uiPath
+      ? { type: 'path', path: cliOpts.uiPath }
+      : cliOpts.uiPort
+        ? { type: 'port', port: cliOpts.uiPort }
+        : { type: 'path', path: path.join(appDataRootDir, 'apps', appId, 'ui') },
+    singalingUrl: cliOpts.signalingUrl,
+    bootstrapUrl: cliOpts.bootstrapUrl,
+    happOrWebhappPath: isHapp
+      ? { type: 'happ', path: happOrWebhappPath }
+      : { type: 'webhapp', path: happOrWebhappPath },
+  };
+}