wlbot 1.1.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2023 Michael Weiner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# WeatherLink Bot (wlbot)
+
+`wlbot` is a Node.js based CLI that can be used to make *some* of the most common API calls that are possible with the [WeatherLink v2 API](https://weatherlink.github.io/v2-api/api-reference).
+
+## Table of Contents
+- [Obtaining a WeatherLink API Key](#obtaining-a-weatherlink-api-key)
+- [Setting Your Environmental Variables](#setting-your-environmental-variables)
+- [Installing `wlbot` via npm](#installing-wlbot-via-npm)
+- [Installing `wlbot` Manually via the Github Repository](#installing-wlbot-manually-via-the-github-repository)
+  - [Install Dependencies](#install-dependencies)
+  - [Clone Repo](#clone-repo)
+  - [Install npm Packages](#install-npm-packages)
+  - [Installing CLI Globally](#installing-cli-globally)
+- [Calling the CLI](#calling-the-cli)
+- [Contributing](#contributing)
+- [License](#license)
+- [References](#references)
+
+## Obtaining a WeatherLink API Key
+No matter how you install `wlbot`, it requires that you have a WeatherLink v2 API Key and Secret. 
+
+The WeatherLink Developer Portal outlines how to get your API key at [https://weatherlink.github.io/v2-api/tutorial](https://weatherlink.github.io/v2-api/tutorial):
+
+> To retrieve your WeatherLink v2 API Key and API Secret you can go to WeatherLink.com and visit the Account page at [https://www.weatherlink.com/account](https://www.weatherlink.com/account).
+>
+> Once on the Account page you can click the Generate v2 Key button to create a new WeatherLink v2 API Key and API Secret.
+
+**Note:** Your API Secret should ***never*** be shared with anyone.
+
+## Setting Your Environmental Variables
+No matter how you install `wlbot`, it requires several **permanent** environmental variables to be set. Before running the CLI locally for this first time, you must set the necessary environment variables. The table below specifies the name and value of the environment variables that are required.
+
+| Environment Variable Name   | Environment Variable Value        |
+| ----------------------------| --------------------------------- |
+| `WEATHER_LINK_API_KEY`      | `<your_api_key>`                  |
+| `WEATHER_LINK_API_SECRET`   | `<your_api_secret>`               |
+| `WEATHER_LINK_BASE_API_URL` | `https://api.weatherlink.com/v2/` |
+
+**Note:** `<your_api_key>` and `<your_api_secret>` should be replaced with the API Key and API Secret that you where given when creating your WeatherLink API as described above.
+
+This article describes how you can [set permanent environment variables on macos or Linux](https://apple.stackexchange.com/questions/356441/how-to-add-permanent-environment-variable-in-zsh).
+
+This article describes how you can [set permanent environment variables on Windows Operating Systems](https://www3.ntu.edu.sg/home/ehchua/programming/howto/Environment_Variables.html#zz-2.).
+
+## Installing `wlbot` via npm
+`wlbot` is listed on the `npm` repository at [https://npmjs.com/package/wlbot](https://npmjs.com/package/wlbot). 
+
+You can globally install the `wlbot` CLI by:
+1. Opening a command line prompt on your machine and running `npm install -g wlbot`. 
+
+This process could take a minute or two, depending on your internet connection.
+
+## Installing `wlbot` Manually via the Github Repository
+It is easy to get a copy of the `wlbot` CLI running locally.
+
+### Install Dependencies
+In order to run `wlbot` locally, the following will need to be installed on your machine:
+- [Node.js](https://nodejs.dev) (required)
+  - Node.js is required to run `wlbot`
+  - **Installation Instructions:** [https://nodejs.org/en/download/](https://nodejs.org/en/download/)
+- [npm](https://www.npmjs.com) (required)
+  - npm is used to manage the packages needed by `wlbot` to run on top of Node.js
+  - **Installation Instructions:** [https://docs.npmjs.com/downloading-and-installing-node-js-and-npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
+
+### Clone Repo
+Navigate to the location on your development machine where you want to place this project's directory and clone the repository by running the following command:
+
+    git clone https://github.com/mike-weiner/wlbot.git
+
+### Install npm Packages
+`wlbot` requires several packages to run on top of Node.js. Those packages can be installed by the following command at the root of the directory for this project running:
+
+    npm install
+
+### Installing CLI Globally
+Once you have all of the environment variables required by the CLI set, we need to globally install the CLI in npm. This will allow you to call `wlbot` on your command line without being in this project's directory.
+
+To globally install the `wlbot` package, navigate to the project's root directory on your command line. This should be the directory where this README is found. Then run the following command:
+
+```
+npm i -g .
+```
+
+**Note:** It is not required that you install `wlbot` globally in npm. However, if it is not installed globally you will only be able to call the `wlbot` command when you are in the directory where you have this project located.
+
+## Calling the CLI
+Congrats! You should now be able to open up a new terminal window and run `wlbot`. You can run `wlbot -h` to get help understanding how to use this CLI.
+
+`wlbot` contains a helpful command to ensure that your environmental variables are set correctly. Run `wlbot config` to print out the values of the environmental variables that are required by `wlbot`. 
+
+You can run `wlbot config -l` to list the full values of the environmental variables. **Note:** Be careful running this command as your WeatherLink API Secret's value will be shown. You don't want to share this with ***anyone***.
+
+### Common Commands
+There are several commands that you will probably call more frequently than others. Some of the more common commands include:
+- `wlbot metadata mine`: This command will return an array of `station-id` numbers for the weather station's that your WeatherLink account has permission to view data for. 
+- `wlbot weather current <station-id>`: This command will return the current weather record for the station whose station id matches `<station-id>`. 
+
+## Contributing
+All contributions are welcome! First, search open issues to see if a ticket has already been created for the issue or feature request that you have. If a ticket does not already exist, open an issue to discuss what contributions you would like to make. All contributions should be developed in a `feature/` branch as a PR will be required before any changes are merged into the `main` branch.
+
+## License
+Distributed under the MIT License. See `LICENSE.txt` for more information.
+
+## References
+Below are several references that were used to help find inspiration for this project, get a starting point for the CLI, and serve as a resource for the WeatherLink API.
+- [WeatherLink Developer Portal](https://weatherlink.github.io)
+- [WeatherLink Portal](https://www.weatherlink.com)
+- [How to Build a Command Line Interface (CLI) Using Node.js](https://cheatcode.co/tutorials/how-to-build-a-command-line-interface-cli-using-node-js)

package/commands/config.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+export default (options) => {
+  const spinner = !options.raw ? ora('Reading Environment Variables').start() : undefined;
+
+  let evValues = {
+    "WEATHER_LINK_API_KEY": process.env.WEATHER_LINK_API_KEY,
+    "WEATHER_LINK_API_SECRET": process.env.WEATHER_LINK_API_SECRET,
+    "WEATHER_LINK_BASE_API_URL": process.env.WEATHER_LINK_BASE_API_URL,
+  }
+
+  if (!options.list) {
+    for (const [key, value] of Object.entries(evValues)) {
+      evValues[key] = evValues[key].slice(0, 3) + "*".repeat(value.length - evValues[key].slice(0, 3).length)
+    }
+  }
+
+  spinner.succeed(chalk.green.bold(`Environment Variables Retrieved`));
+  return console.log(JSON.stringify(evValues, undefined, 2))
+};

package/commands/metadata/catalog.js

@@ -0,0 +1,40 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { buildWeatherLinkApiUrl, checkForRequired } from '../../lib/utils.js';
+
+export default (options) => {
+  const spinner = !options.raw ? ora('Retrieving Sensor Catalog').start() : undefined;
+
+  const envVars = checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+  if (!envVars.exist) {
+    return console.log(`${chalk.red.bold(`Missing Environment Variable(s):`)} ${envVars.missing.join(", ")}`);
+  }
+
+  const API_KEY = process.env.WEATHER_LINK_API_KEY;
+
+  axios.get(
+    buildWeatherLinkApiUrl(
+      `sensor-catalog`,
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) },
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) }
+    )
+  )
+    .then((response) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(response.data));
+      }
+
+      spinner.succeed(chalk.green.bold(`Catalog Retrieved`));
+      return console.dir(response.data, { depth: null })
+    })
+    .catch((error) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(error.response.data));
+      }
+
+      spinner.fail('Failed to Retrieve Catalog');
+      return console.log(`${chalk.red.bold(`Error ${error.response.status}:`)} ${error.response.data.message}`);
+    })
+};

package/commands/metadata/mine.js

@@ -0,0 +1,46 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { buildWeatherLinkApiUrl, checkForRequired } from '../../lib/utils.js';
+
+export default (options) => {
+  const spinner = !options.raw ? ora('Searching for Stations').start() : undefined;
+
+  const envVars = checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+  if (!envVars.exist) {
+    return console.log(`${chalk.red.bold(`Missing Environment Variable(s):`)} ${envVars.missing.join(", ")}`);
+  }
+
+  const API_KEY = process.env.WEATHER_LINK_API_KEY;
+
+  axios.get(
+    buildWeatherLinkApiUrl(
+      'stations',
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) },
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) }
+    )
+  )
+    .then((response) => {
+
+      if (options.raw) {
+        return console.log(JSON.stringify(response.data));
+      }
+
+      let stationIdList = [];
+      response.data.stations.forEach(station => {
+        stationIdList.push(station.station_id);
+      });
+
+      spinner.succeed(chalk.green.bold(`${stationIdList.length} Station(s) Found`));
+      return console.log(stationIdList);
+    })
+    .catch((error) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(error.response.data));
+      }
+
+      spinner.fail('Unable to Find Stations');
+      return console.log(`${chalk.red.bold(`Error ${error.response.status}:`)} ${error.response.data.message}`);
+    })
+};

package/commands/metadata/stations.js

@@ -0,0 +1,40 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { buildWeatherLinkApiUrl, checkForRequired } from '../../lib/utils.js';
+
+export default (stationIds, options) => {
+  const spinner = !options.raw ? ora('Searching for Stations').start() : undefined;
+
+  const envVars = checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+  if (!envVars.exist) {
+    return console.log(`${chalk.red.bold(`Missing Environment Variable(s):`)} ${envVars.missing.join(", ")}`);
+  }
+
+  const API_KEY = process.env.WEATHER_LINK_API_KEY;
+
+  axios.get(
+    buildWeatherLinkApiUrl(
+      `stations/${stationIds}`,
+      { "api-key": API_KEY, "station-ids": String(stationIds), "t": String(Math.round(Date.now() / 1000)) },
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) }
+    )
+  )
+    .then((response) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(response.data));
+      }
+
+      spinner.succeed(chalk.green.bold(`${response.data.stations.length} Station(s) Found`));
+      return console.log(response.data);
+    })
+    .catch((error) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(error.response.data));
+      }
+
+      spinner.fail('Unable to Find Stations');
+      return console.log(`${chalk.red.bold(`Error ${error.response.status}:`)} ${error.response.data.message}`);
+    })
+};

package/commands/status.js

@@ -0,0 +1,39 @@
+import axios from 'axios';
+
+export default function(service, options) {
+
+  // Mapping of wlbot's shorthand for service names to Davis Instrument's official names.
+  const fullServiceName = {
+    'api'          : 'APIs and Data Feeds',
+    'dataingest'   : 'Data Ingestion',
+    'mobile'       : 'Mobile Applications',
+    'syscomms'     : 'System Communication',
+    'website'      : 'WeatherLink Website'
+  };
+
+  return (
+   axios.get(
+      'https://0886445102835570.hostedstatus.com/1.0/status/600712dea9c1290530967bc6'
+    )
+    .then((response) => {
+
+      var requestedDavisServices = service === 'all' ? 
+        response.data.result.status
+        :
+        response.data.result.status.filter(davisService => {
+          return davisService.name === fullServiceName[service];
+        });
+
+      return requestedDavisServices;
+
+    })
+    .catch((error) => {
+      return ({
+        'error': {
+          'msg': `${error.response.data.message}`,
+          'status': `${error.response.status}`
+        }
+      });
+    })
+  );
+};

package/commands/weather/current.js

@@ -0,0 +1,40 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { buildWeatherLinkApiUrl, checkForRequired } from '../../lib/utils.js';
+
+export default (stationId, options) => {
+  const spinner = !options.raw ? ora('Retrieving Current Weather Data').start() : undefined;
+
+  const envVars = checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+  if (!envVars.exist) {
+    return console.log(`${chalk.red.bold(`Missing Environment Variable(s):`)} ${envVars.missing.join(", ")}`);
+  }
+
+  const API_KEY = process.env.WEATHER_LINK_API_KEY;
+
+  axios.get(
+    buildWeatherLinkApiUrl(
+      `current/${stationId}`,
+      { "api-key": API_KEY, "station-id": String(stationId), "t": String(Math.round(Date.now() / 1000)) },
+      { "api-key": API_KEY, "t": String(Math.round(Date.now() / 1000)) }
+    )
+  )
+    .then((response) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(response.data));
+      }
+
+      spinner.succeed(chalk.green.bold(`Current Weather Data Retrieved`));
+      return console.dir(response.data, { depth: null })
+    })
+    .catch((error) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(error.response.data));
+      }
+
+      spinner.fail('Failed to Retrieve Current Weather Data');
+      return console.log(`${chalk.red.bold(`Error ${error.response.status}:`)} ${error.response.data.message}`);
+    })
+};

package/commands/weather/historic.js

@@ -0,0 +1,46 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { buildWeatherLinkApiUrl, checkForRequired, dateRangeIsValid } from '../../lib/utils.js';
+
+export default (stationId, startTimestamp, endTimestamp, options) => {
+  const spinner = !options.raw ? ora('Retrieving Historical Weather Data').start() : undefined;
+
+  const envVars = checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+  if (!envVars.exist) {
+    return console.log(`${chalk.red.bold(`Missing Environment Variable(s):`)} ${envVars.missing.join(", ")}`);
+  }
+
+  const resultsOfDateRangeCheck = dateRangeIsValid(startTimestamp, endTimestamp);
+
+  if (!resultsOfDateRangeCheck.isValid) {
+    return console.log(`${chalk.red.bold(`Error:`)} ${resultsOfDateRangeCheck.msg}`);
+  }
+
+  const API_KEY = process.env.WEATHER_LINK_API_KEY;
+
+  axios.get(
+    buildWeatherLinkApiUrl(
+      `historic/${stationId}`,
+      { "api-key": API_KEY, "end-timestamp": endTimestamp, "start-timestamp": startTimestamp, "station-id": String(stationId), "t": String(Math.round(Date.now() / 1000)) },
+      { "api-key": API_KEY, "end-timestamp": endTimestamp, "start-timestamp": startTimestamp, "t": String(Math.round(Date.now() / 1000)) }
+    )
+  )
+    .then((response) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(response.data));
+      }
+
+      spinner.succeed(chalk.green.bold(`Historical Weather Data Retrieved`));
+      return console.dir(response.data, { depth: null })
+    })
+    .catch((error) => {
+      if (options.raw) {
+        return console.log(JSON.stringify(error.response.data));
+      }
+
+      spinner.fail('Failed to Retrieve Historical Weather Data');
+      return console.log(`${chalk.red.bold(`Error ${error.response.status}:`)} ${error.response.data.message}`);
+    })
+};

package/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { Command, Argument } from 'commander';
+
+import catalog from './commands/metadata/catalog.js';
+import mine from './commands/metadata/mine.js';
+import stations from './commands/metadata/stations.js';
+
+import current from './commands/weather/current.js';
+import historic from './commands/weather/historic.js';
+
+import config from './commands/config.js';
+
+import status from './commands/status.js';
+
+const program = new Command();
+
+program
+  .description("A CLI for the WeatherLink Live API.")
+  .name("wlbot")
+  .version('1.1.0')
+  .usage('<command>');
+
+const metadata = program.command("metadata")
+  .description("Subcommand for accessing all metadata routes from the WeatherLink v2 API.");
+
+metadata.command("catalog")
+  .description("Get a catalog of all available sensor types and the data reported by each sensor.")
+  .option("-r, --raw", "Display the raw response from the WeatherLink API.")
+  .action(catalog);
+
+metadata.command("mine")
+  .description("Returns an array of Weather Station Id(s) that are associated with your WeatherLink API Key.")
+  .option("-r, --raw", "Display the raw response from the WeatherLink API.")
+  .action(mine);
+
+metadata.command("stations")
+  .description("Returns all available information about 1 or more weather stations associated with your WeatherLink API Key.")
+  .argument('<station-ids>', 'A comma-separated list of Weather Station Id(s) that you want information about.')
+  .option("-r, --raw", "Display the raw response from the WeatherLink API.")
+  .action(stations);
+
+const weather = program.command("weather")
+  .description("Subcommand for accessing all weather routes from the WeatherLink v2 API.");
+
+weather.command("current")
+  .description("Get the current weather data for 1 weather station associated with your WeatherLink API Key.")
+  .argument('<station-id>', 'The Station ID of the weather station that you want current weather data for.')
+  .option("-r, --raw", "Display the raw response from the WeatherLink API.")
+  .action(current);
+
+weather.command("historic")
+  .description("Get the historical weather data for 1 weather station associated with your WeatherLink API Key within a 24hr period.")
+  .argument('<station-id>', 'The Station ID of the weather station that you want current weather data for.')
+  .argument('<start-timestamp>', 'A Unix timestamp marking the beginning of the historical period (must be earlier than end-timestamp but not more than 24 hours earlier).')
+  .argument('<end-timestamp>', 'A Unix timestamp marking the end of the historical period (must be later than start-timestamp but not more than 24 hours later).')
+  .option("-r, --raw", "Display the raw response from the WeatherLink API.")
+  .action(historic);
+
+program.command("config")
+  .description("Display the value(s) of the environment variable(s) being consumed.")
+  .option("-l, --list", "List the complete values of the environment variables.")
+  .action(config);
+
+program.command("status")
+  .description("Retrieves the operational status(es) of Davis Instrument's services.")
+  .addArgument(new Argument('[service]', 'The Davis Instrument service that you want to obtain the operational status of.').choices(['all', 'api', 'dataingest', 'mobile', 'syscomms', 'website']).default('all'))
+  .action((service, options) => {
+    status(service, options).then((result) => {
+      if (!Array.isArray(result)) {
+        console.log('Error: ' + result.error.msg);
+      } else {
+        result.forEach((requestedService) => {
+          console.log(requestedService.name + ' is ' + requestedService.status + ' (Status Code: ' + requestedService.status_code + ')');
+        });
+      }
+    });
+  });
+
+program.commands.sort((a, b) => a._name.localeCompare(b._name));
+program.parse(process.argv);

package/lib/utils.js

@@ -0,0 +1,74 @@
+import crypto from 'crypto';
+
+/**
+ * Build and return the URL to query the WeatherLink Live API with.
+ * 
+ * @param {String} endpoint The endpoint in the WeatherLink Live API that you want to query.
+ * @param {Object} signature_parameters An object containing the required information to build the API Signature for each request.
+ * @param {Object} uri_parameters An object containing the required query parameters for the requested endpoint to query.
+ * @return {String} The string to make the API call with to retrieve the requested data.
+ */
+export function buildWeatherLinkApiUrl(endpoint, signature_parameters, uri_parameters) {
+  const BASE_URL = process.env.WEATHER_LINK_BASE_API_URL;
+  const API_SECRET = process.env.WEATHER_LINK_API_SECRET;
+
+  var apiSignature = "";
+  for (const key in signature_parameters) {
+    apiSignature = apiSignature + key + signature_parameters[key]
+  }
+
+  var hmac = crypto.createHmac('sha256', API_SECRET);
+  var hashedData = hmac.update(apiSignature).digest('hex');
+
+  var apiRequestURL = BASE_URL + endpoint + "?";
+  Object.keys(uri_parameters).forEach((key, index) => {
+    if (index === 0) {
+      apiRequestURL = apiRequestURL + key + "=" + uri_parameters[key];
+    } else {
+      apiRequestURL = apiRequestURL + "&" + key + "=" + uri_parameters[key];
+    }
+  });
+  
+  apiRequestURL = apiRequestURL + "&api-signature=" + hashedData;
+  return apiRequestURL;
+}
+
+/**
+ * Check that the required environmental variables are defined to complete the specific action.
+ * 
+ * @param {Array} envVars An array of the names of the environmental variables to check for values.
+ * @return {Object} An object containing whether all 
+ */
+export function checkForRequired(envVars) {
+  let missingEnvVars = []
+
+  for (const envVar of envVars) {
+    if (!process.env[envVar]){
+      missingEnvVars.push(envVar)
+    }
+  }
+
+  if (missingEnvVars.length != 0) {
+    return {"exist": false, "missing": missingEnvVars};
+  }
+
+  return {"exist": true, "missing": missingEnvVars};
+}
+
+/**
+ * Determines if the start and end timestamps the user provides are valid.
+ * 
+ * @param {Integer} startTimestamp A Unix timestamp marking the beginning of the historical period (must be earlier than end-timestamp but not more than 24 hours earlier).
+ * @param {Integer} endTimestamp A Unix timestamp marking the end of the historical period (must be later than start-timestamp but not more than 24 hours later).
+ */
+export function dateRangeIsValid(startTimestamp, endTimestamp) {
+  if (startTimestamp <= 0 || endTimestamp <= 0) {
+    return {isValid: false, msg:"start-timestamp and end-timestamp must be greater than 0."};
+  }
+  
+  if (startTimestamp >= endTimestamp) {
+    return {isValid: false, msg:"start-timestamp must be less than end-timestamp."};
+  }
+
+  return {isValid: true, msg:""};
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "wlbot",
+  "version": "1.1.0",
+  "description": "A CLI for the WeatherLink Live API.",
+  "keywords": [
+    "Davis Instruments", 
+    "WeatherLink v2 API", 
+    "WeatherLink API", 
+    "Weather Link API CLI",
+    "WeatherLink",
+    "WeatherLink CLI",
+    "weather cli"
+  ],
+  "homepage": "https://github.com/mike-weiner/wlbot",
+  "bugs": {
+    "url": "https://github.com/mike-weiner/wlbot/issues",
+    "email": "michael.weiner@hey.com"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Michael Weiner", 
+    "email": "michael.weiner@hey.com",
+    "url": "https://michaelweiner.org"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "bin": {
+    "wlbot": "./index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mike-weiner/wlbot.git"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "axios": "^0.27.2",
+    "chalk": "^5.0.1",
+    "commander": "^9.4.0",
+    "ora": "^6.1.2"
+  },
+  "devDependencies": {
+    "chai": "^4.3.6",
+    "mocha": "^10.0.0"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/test/utils.test.js

@@ -0,0 +1,108 @@
+import { buildWeatherLinkApiUrl, checkForRequired, dateRangeIsValid } from '../lib/utils.js';
+import chai from 'chai';
+
+describe('buildWeatherLinkApiUrl', () => {
+  beforeEach(() => {
+    // Set the environment variables
+    process.env.WEATHER_LINK_API_KEY = 'sampleKey';
+    process.env.WEATHER_LINK_API_SECRET = 'sampleSecret';
+    process.env.WEATHER_LINK_BASE_API_URL = 'https://api.weatherlink.com/v2/';
+  });
+
+  it('Endpoint: current/13', () => {
+    chai.expect(
+      buildWeatherLinkApiUrl(
+        `current/13`, 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 'station-id': String(13), 't': String(1660759469)}, 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 't': String(1660759469)}
+      )
+    ).to.equal('https://api.weatherlink.com/v2/current/13?api-key=sampleKey&t=1660759469&api-signature=dcf2f0eafc43ec8b6d6a1a7acfc6faa44f9bc1045124d7d6416f2f486ff72e95')
+  });
+
+  it('Endpoint: stations', () => {
+    chai.expect(
+      buildWeatherLinkApiUrl(
+        'stations', 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 't': String(1660757289)}, 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 't': String(1660757289)}
+      )
+    ).to.equal('https://api.weatherlink.com/v2/stations?api-key=sampleKey&t=1660757289&api-signature=1663a50336ae4b7d975e322ad010e297d4ec487c5d3d9d4dad1d8a4a9e53d606')
+  });
+
+  it('Endpoint: stations/13,14,15', () => {
+    chai.expect(
+      buildWeatherLinkApiUrl(
+        `stations/13,14,15`, 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 'station-ids': '13,14,15', 't': String(1660759608)}, 
+        {'api-key': process.env.WEATHER_LINK_API_KEY, 't': String(1660759608)}
+      )
+    ).to.equal('https://api.weatherlink.com/v2/stations/13,14,15?api-key=sampleKey&t=1660759608&api-signature=7accbcf70808449f944e5da9e3e06db0aae7362870e7ace8312d5d9e8103d274')
+  });
+});
+
+describe('checkForRequired', () => {
+  
+  beforeEach(() => {
+    // Set the environment variables
+    process.env.WEATHER_LINK_API_KEY = 'sampleKey';
+    process.env.WEATHER_LINK_API_SECRET = 'sampleSecret';
+    process.env.WEATHER_LINK_BASE_API_URL = 'https://api.weatherlink.com/v2/';
+  });
+
+  it('Missing All Env Vars', () => {
+    chai.expect(
+      checkForRequired(["WEATHER_LINK_VERY_FAKE_NONEXISTENT"])
+    ).to.deep.equal({"exist": false, "missing": ["WEATHER_LINK_VERY_FAKE_NONEXISTENT"]})
+  });
+
+  it('All Env Vars Defined', () => {
+    chai.expect(
+      checkForRequired(["WEATHER_LINK_API_KEY", "WEATHER_LINK_API_SECRET", "WEATHER_LINK_BASE_API_URL"])
+    ).to.deep.equal({"exist": true, "missing": []})
+  });
+});
+
+describe('dateRangeIsValid', () => {
+
+  it('Start Timestamp is Before End Timestamp', () => {
+    chai.expect(
+      dateRangeIsValid(1673472399, 1673494000).isValid
+    ).to.equal(true)
+  });
+
+  it('Start Timestamp is the Same as End Timestamp', () => {
+    chai.expect(
+      dateRangeIsValid(1673494000, 1673494000).isValid
+    ).to.equal(false)
+  });
+
+  it('Start Timestamp is After End Timestamp', () => {
+    chai.expect(
+      dateRangeIsValid(1673494010, 1673494000).isValid
+    ).to.equal(false)
+  });
+
+  it('Start Timestamp is 0', () => {
+    chai.expect(
+      dateRangeIsValid(0, 1673494000).isValid
+    ).to.equal(false)
+  });
+
+  it('Start Timestamp is Negative', () => {
+    chai.expect(
+      dateRangeIsValid(-10, 1673494000).isValid
+    ).to.equal(false)
+  });
+
+  it('End Timestamp is 0', () => {
+    chai.expect(
+      dateRangeIsValid(1673494010, 0).isValid
+    ).to.equal(false)
+  });
+
+  it('End Timestamp is Negative', () => {
+    chai.expect(
+      dateRangeIsValid(1673494010, -10).isValid
+    ).to.equal(false)
+  });
+});