feat: harper login and logout

This saves jwts, per target, in your ~/.harper directory.

Author: dawsontoth

bin/cliCredentials.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+const fs = require('fs-extra');
+
+function getHomeDir() {
+	let homeDir = undefined;
+	try {
+		homeDir = os.homedir();
+	} catch {
+		// could get here in android
+		homeDir = process.env.HOME;
+	}
+	return homeDir;
+}
+
+function getCredentialsFile() {
+	return path.join(getHomeDir(), '.harper', 'credentials.json');
+}
+
+function getCredentialsDir() {
+	return path.join(getHomeDir(), '.harper');
+}
+
+/**
+ * Loads the JWT credentials from the ~/.harper/credentials.json file.
+ * @returns {Object|null} The credentials object or null if not found.
+ */
+function loadCredentials() {
+	const credentialsFile = getCredentialsFile();
+	if (fs.existsSync(credentialsFile)) {
+		try {
+			return fs.readJsonSync(credentialsFile);
+		} catch (err) {
+			console.error(`Error reading credentials file: ${err.message}`);
+			return null;
+		}
+	}
+	return null;
+}
+
+/**
+ * Saves the JWT credentials to the ~/.harper/credentials.json file.
+ * @param {Object} credentials The credentials object containing operation_token and refresh_token.
+ */
+function saveCredentials(credentials) {
+	try {
+		const allCredentials = loadCredentials() || {};
+		const { target, ...tokens } = credentials;
+
+		if (target) {
+			allCredentials.targets = allCredentials.targets || {};
+			allCredentials.targets[target] = tokens;
+			allCredentials.last_target = target;
+		} else {
+			// Fallback for when target is not provided (shouldn't happen with new login)
+			Object.assign(allCredentials, tokens);
+		}
+
+		fs.ensureDirSync(getCredentialsDir());
+		fs.writeJsonSync(getCredentialsFile(), allCredentials, { spaces: 2, mode: 0o600 });
+	} catch (err) {
+		console.error(`Error saving credentials file: ${err.message}`);
+	}
+}
+
+/**
+ * Deletes the credentials for a specific target or all if no target provided.
+ * @param {string} [target] The target URL to logout from.
+ */
+function clearCredentials(target) {
+	const credentialsFile = getCredentialsFile();
+	try {
+		if (target) {
+			const allCredentials = loadCredentials();
+			if (allCredentials && allCredentials.targets && allCredentials.targets[target]) {
+				delete allCredentials.targets[target];
+				if (allCredentials.last_target === target) {
+					const remainingTargets = Object.keys(allCredentials.targets);
+					allCredentials.last_target = remainingTargets.length > 0 ? remainingTargets[0] : null;
+				}
+				fs.writeJsonSync(credentialsFile, allCredentials, { spaces: 2, mode: 0o600 });
+				console.log(`Logged out from ${target}`);
+			}
+		} else if (fs.existsSync(credentialsFile)) {
+			fs.removeSync(credentialsFile);
+			console.log('Logged out from all targets');
+		}
+	} catch (err) {
+		console.error(`Error clearing credentials file: ${err.message}`);
+	}
+}
+
+module.exports = {
+	loadCredentials,
+	saveCredentials,
+	clearCredentials,
+};

bin/cliOperations.js

@@ -11,6 +11,7 @@ const { packageDirectory } = require('../components/packageComponent.ts');
 const { encode } = require('cbor-x');
 const { getHdbPid } = require('../utility/processManagement/processManagement.js');
 const { initConfig, getConfigPath } = require('../config/configUtils.js');
+const { loadCredentials } = require('./cliCredentials.js');
 
 const OP_ALIASES = { deploy: 'deploy_component', package: 'package_component' };
 
@@ -56,15 +57,29 @@ function buildRequest() {
 	return req;
 }
 
+/**
+ * Resolves the target URL from various sources.
+ * @param {Object} req The request object.
+ * @param {Object} allCredentials Stored credentials.
+ * @returns {string|null} The resolved target URL.
+ */
+function resolveTarget(req, allCredentials) {
+	return (
+		req.target ||
+		process.env.HARPER_CLI_TARGET ||
+		process.env.CLI_TARGET ||
+		(allCredentials && allCredentials.last_target)
+	);
+}
+
 /**
  * Using a unix domain socket will send a request to hdb operations API server
  * @param req
  * @returns {Promise<void>}
  */
-async function cliOperations(req) {
-	if (!req.target) {
-		req.target = process.env.HARPER_CLI_TARGET || process.env.CLI_TARGET;
-	}
+async function cliOperations(req, skipResponseLog = false) {
+	const allCredentials = loadCredentials();
+	req.target = resolveTarget(req, allCredentials);
 	let target;
 	if (req.target) {
 		try {
@@ -76,15 +91,17 @@ async function cliOperations(req) {
 				throw error;
 			}
 		}
+		const resolvedTarget = `${target.protocol}//${target.hostname}${target.port ? ':' + target.port : ''}`;
 		target = {
 			protocol: target.protocol,
 			hostname: target.hostname,
 			port: target.port,
 			username: req.username || target.username || process.env.HARPER_CLI_USERNAME || process.env.CLI_TARGET_USERNAME,
 			password: req.password || target.password || process.env.HARPER_CLI_PASSWORD || process.env.CLI_TARGET_PASSWORD,
 			rejectUnauthorized: req.rejectUnauthorized,
+			resolvedTarget,
 		};
-		console.error(`Connecting to ${target.protocol}//${target.hostname}:${target.port}`);
+		console.error(`Connecting to ${resolvedTarget}`);
 	} else {
 		// if we aren't doing a targeted operation (like deploy), we initialize the config and verify that local harper
 		// is running and that we can communicate with it.
@@ -110,6 +127,17 @@ async function cliOperations(req) {
 		options.headers = { 'Content-Type': 'application/json' };
 		if (target?.username) {
 			options.headers.Authorization = `Basic ${Buffer.from(`${target.username}:${target.password}`).toString('base64')}`;
+		} else if (allCredentials) {
+			let tokens = null;
+			if (target && allCredentials.targets && allCredentials.targets[target.resolvedTarget]) {
+				tokens = allCredentials.targets[target.resolvedTarget];
+			} else if (allCredentials.operation_token) {
+				tokens = allCredentials;
+			}
+
+			if (tokens && tokens.operation_token) {
+				options.headers.Authorization = `Bearer ${tokens.operation_token}`;
+			}
 		}
 		if (req.cborEncode) {
 			options.headers['Content-Type'] = 'application/cbor';
@@ -141,7 +169,13 @@ async function cliOperations(req) {
 			process.exit(1);
 		}
 
-		console.log(responseLog);
+		if (!skipResponseLog) {
+			console.log(responseLog);
+		}
+
+		if (target) {
+			responseData.resolvedTarget = target.resolvedTarget;
+		}
 
 		return responseData;
 	} catch (err) {

bin/harper.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
+require('dotenv').config();
 const fs = require('node:fs');
 const path = require('node:path');
 const logger = require('../utility/logging/harper_logger.js');
@@ -23,6 +24,8 @@ copy-db <source> <target>       - Copies a database from source path to target p
 dev <path>                      - Run the application in dev mode with debugging, foreground logging, no auth
 install                         - Install harperdb
 <api-operation> <param>=<value> - Run an API operation and return result to the CLI, not all operations are supported
+login [username]                - Login to a remote or local Harper instance
+logout [target]                 - Logout from Harper and clear saved JWT
 register                        - Register harperdb
 renew-certs                     - Generate a new set of self-signed certificates
 restart                         - Restart the harperdb background process
@@ -79,6 +82,16 @@ async function harper() {
 				.then(() => 'Your instance of Harper is up to date!');
 		case SERVICE_ACTIONS_ENUM.STATUS:
 			return require('./status.js')();
+		case SERVICE_ACTIONS_ENUM.LOGIN: {
+			const target = process.argv[3];
+			const username = process.argv[4];
+			const { login } = require('./login.js');
+			return login(target, username);
+		}
+		case SERVICE_ACTIONS_ENUM.LOGOUT: {
+			const target = process.argv[3];
+			return require('./logout.js')(target);
+		}
 		case SERVICE_ACTIONS_ENUM.RENEWCERTS:
 			return require('../security/keys.js')
 				.renewSelfSigned()