Add type-strip mode: run Harper directly from .ts sources

.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"5206baae-267d-4d02-bedd-55b8d6b8cf05","pid":3219805,"procStart":"41160224","acquiredAt":1778799452286}

bin/cliOperations.ts

@@ -1,17 +1,19 @@
 'use strict';
 
-import * as envMgr from '../utility/environment/environmentManager.ts';
-envMgr.initSync();
 import * as terms from '../utility/hdbTerms.ts';
 import { httpRequest } from '../utility/common_utils.ts';
 import * as path from 'path';
-import * as fs from 'fs-extra';
+import fs from 'fs-extra';
 import * as YAML from 'yaml';
 import { packageDirectory } from '../components/packageComponent.ts';
 import { encode } from 'cbor-x';
-import { getHdbPid } from '../utility/processManagement/processManagement.js';
-import { initConfig, getConfigPath } from '../config/configUtils.js';
-
+import { getHdbPid } from '../utility/processManagement/processManagement.ts';
+import { initConfig, getConfigPath } from '../config/configUtils.ts';
+try {
+	envMgr.initSync();
+} catch {
+	/* tolerate ESM cycle TDZ; bin entry will re-call later */
+}
 const OP_ALIASES = { deploy: 'deploy_component', package: 'package_component' };
 
 export { cliOperations, buildRequest };

bin/copyDb.ts

@@ -1,7 +1,8 @@
 import { getDatabases, getDefaultCompression, resetDatabases } from '../resources/databases.ts';
 import { open, asBinary } from 'lmdb';
 import { join } from 'path';
-import { move, remove } from 'fs-extra';
+import _fs_extra from 'fs-extra';
+const { move, remove } = _fs_extra;
 import { existsSync, mkdirSync } from 'node:fs';
 import { get } from '../utility/environment/environmentManager.ts';
 import OpenEnvironmentObject from '../utility/lmdb/OpenEnvironmentObject.ts';
@@ -10,7 +11,7 @@ import { INTERNAL_DBIS_NAME, AUDIT_STORE_NAME } from '../utility/lmdb/terms.ts';
 import { CONFIG_PARAMS, DATABASES_DIR_NAME } from '../utility/hdbTerms.ts';
 import { AUDIT_STORE_OPTIONS } from '../resources/auditStore.ts';
 import { describeSchema } from '../dataLayer/schemaDescribe.ts';
-import { updateConfigValue } from '../config/configUtils.js';
+import { updateConfigValue } from '../config/configUtils.ts';
 import * as hdbLogger from '../utility/logging/harper_logger.ts';
 import { RocksDatabase, type RocksDatabaseOptions } from '@harperfast/rocksdb-js';
 import { RocksIndexStore } from '../resources/RocksIndexStore.ts';

bin/harper.ts

@@ -4,7 +4,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import logger from '../utility/logging/harper_logger.ts';
-import * as cliOperations from './cliOperations.ts';
 import { packageJson } from '../utility/packageUtils.js';
 import checkNode from '../launchServiceScripts/utility/checkNodeVersion.js';
 import * as hdbTerms from '../utility/hdbTerms.ts';
@@ -38,6 +37,36 @@ version                         - Print the version
 deploy                          - Deploy the application locally or remotely with target=<remote url>
 `;
 
+/**
+ * Initialize the environment manager. Call before dynamically importing the
+ * subcommand module so any module-load reads of `env.get(…)` see a populated
+ * configuration. Side-effectful initialization is deferred to `onStartup(…)`
+ * hooks; call `runServerStartup()` once the subcommand module has finished
+ * loading to drain them.
+ */
+async function initEnv() {
+	const env = await import('../utility/environment/environmentManager.ts');
+	env.initSync();
+}
+
+async function runServerStartup() {
+	const lifecycle = await import('../utility/lifecycle.ts');
+	await lifecycle.runStartup();
+}
+
+/**
+ * Resolve a default-exported function from a dynamically-imported module that
+ * may have been loaded from a .ts source (ESM: `mod.default` is the function)
+ * or a tsc-compiled .js (CJS-wrapped: `mod.default` is the CJS exports object
+ * and `mod.default.default` is the function).
+ */
+function getDefaultExport(mod: any): any {
+	if (typeof mod === 'function') return mod;
+	if (typeof mod.default === 'function') return mod.default;
+	if (typeof mod.default?.default === 'function') return mod.default.default;
+	return mod.default ?? mod;
+}
+
 async function harper() {
 	let nodeResults = checkNode();
 
@@ -61,34 +90,41 @@ async function harper() {
 	switch (service) {
 		case SERVICE_ACTIONS_ENUM.HELP:
 			return HELP;
-		case SERVICE_ACTIONS_ENUM.START:
-			return require('./run').launch();
-		case SERVICE_ACTIONS_ENUM.INSTALL:
-			return (require('./install').default || require('./install'))();
-		case SERVICE_ACTIONS_ENUM.STOP:
-			return (require('./stop').default || require('./stop'))().then(() => {
+		case SERVICE_ACTIONS_ENUM.START: {
+			await initEnv();
+			const mod = await import('./run.ts');
+			// runStartup() is drained inside run.ts main() after initialize()
+			// completes, so server.X singletons and auth's table() resolution
+			// see a populated env / installed hdbBasePath.
+			return mod.launch();
+		}
+		case SERVICE_ACTIONS_ENUM.INSTALL: {
+			return getDefaultExport(await import('./install.ts'))();
+		}
+		case SERVICE_ACTIONS_ENUM.STOP: {
+			await initEnv();
+			return getDefaultExport(await import('./stop.ts'))().then(() => {
 				process.exit(0);
 			});
+		}
 		case SERVICE_ACTIONS_ENUM.RESTART:
-			return require('./restart').restart({});
+			return (await import('./restart.ts')).restart({});
 		case SERVICE_ACTIONS_ENUM.VERSION:
 			return packageJson.version;
 		case SERVICE_ACTIONS_ENUM.UPGRADE:
 			logger.setLogLevel(hdbTerms.LOG_LEVELS.INFO);
-			// The require is here to better control the flow of imports when this module is called.
-			return require('./upgrade.js')
-				.upgrade(null)
-				.then(() => 'Your instance of Harper is up to date!');
-		case SERVICE_ACTIONS_ENUM.STATUS:
-			return (require('./status').default || require('./status'))();
+			return (await import('./upgrade.ts')).upgrade(null).then(() => 'Your instance of Harper is up to date!');
+		case SERVICE_ACTIONS_ENUM.STATUS: {
+			return getDefaultExport(await import('./status.ts'))();
+		}
 		case SERVICE_ACTIONS_ENUM.RENEWCERTS:
-			return require('../security/keys')
+			return (await import('../security/keys.ts'))
 				.renewSelfSigned()
 				.then(() => 'Successfully renewed self-signed certificates');
 		case SERVICE_ACTIONS_ENUM.COPYDB: {
 			let sourceDb = process.argv[3];
 			let targetDbPath = process.argv[4];
-			return require('./copyDb').copyDb(sourceDb, targetDbPath);
+			return (await import('./copyDb.ts')).copyDb(sourceDb, targetDbPath);
 		}
 		case SERVICE_ACTIONS_ENUM.DEV:
 			process.env.DEV_MODE = 'true';
@@ -127,17 +163,27 @@ async function harper() {
 			}
 		}
 		// fall through
-		case undefined: // run harperdb in the foreground in standard mode
-			return require('./run').main();
-		default:
+		case undefined: {
+			// run harperdb in the foreground in standard mode.
+			// runStartup() is drained inside run.ts main() after initialize().
+			await initEnv();
+			const mod = await import('./run.ts');
+			return mod.main();
+		}
+		default: {
+			const cliOperations = await import('./cliOperations.ts');
 			const cliApiOp = cliOperations.buildRequest();
 			logger.trace('calling cli operations with:', cliApiOp);
 			await cliOperations.cliOperations(cliApiOp);
 			return;
+		}
 	}
 }
 export { harper };
-if (require.main === module) {
+// In CJS (dist), `module` is defined and we check the entry. In ESM (typestrip),
+// `module` is undefined; this file is only run directly as a CLI, so treat as main.
+const isEntry = typeof module === 'undefined' || require.main === module;
+if (isEntry) {
 	harper()
 		.then((message) => {
 			if (message) {

bin/restart.ts

@@ -4,17 +4,20 @@
 import { isMainThread, parentPort } from 'worker_threads';
 import * as hdbTerms from '../utility/hdbTerms.ts';
 import hdbLogger from '../utility/logging/harper_logger.ts';
-import * as processMan from '../utility/processManagement/processManagement.js';
+import * as processMan from '../utility/processManagement/processManagement.ts';
 import { compactOnStart } from './copyDb.ts';
-import { restartWorkers, onMessageByType, shutdownWorkersNow } from '../server/threads/manageThreads.js';
+import { restartWorkers, onMessageByType, shutdownWorkersNow } from '../server/threads/manageThreads.ts';
 import { handleHDBError, hdbErrors } from '../utility/errors/hdbError.ts';
 const { HTTP_STATUS_CODES } = hdbErrors;
 import * as envMgr from '../utility/environment/environmentManager.ts';
 import * as path from 'node:path';
 import { unlinkSync } from 'node:fs';
 import { getThisNodeName } from '../server/nodeName.ts';
-envMgr.initSync();
-
+try {
+	envMgr.initSync();
+} catch {
+	/* tolerate ESM cycle TDZ; bin entry will re-call later */
+}
 const RESTART_RESPONSE = `Restarting Harper. This may take up to ${hdbTerms.RESTART_TIMEOUT_MS / 1000} seconds.`;
 const INVALID_SERVICE_ERR = 'Invalid service';
 
@@ -65,8 +68,8 @@
 			// connections and hanging. So we need to explicitly close down all the workers and then start the new process
 			// and shut down.
 			hdbLogger.debug('Shutdown workers');
 			await shutdownWorkersNow();
-			const { closeServers } = require('../server/threads/threadServer.js');
+			const { closeServers } = await import('../server/threads/threadServer.ts');
 			await closeServers();
 			await processMan.cleanupChildrenProcesses(false);
 			// remove pid file so it doesn't trip up the launch

bin/run.ts

@@ -1,24 +1,27 @@
 'use strict';
 
 import * as env from '../utility/environment/environmentManager.ts';
-env.initSync();
-
+try {
+	env.initSync();
+} catch {
+	/* tolerate ESM cycle TDZ; bin entry will re-call later */
+}
 // This unused restart import is here so that main thread loads ITC event listener defined in restart file. Do not remove.
 import './restart.ts';
 import * as terms from '../utility/hdbTerms.ts';
 const { CONFIG_PARAMS } = terms;
 import hdbLogger from '../utility/logging/harper_logger.ts';
-import * as fs from 'fs-extra';
+import fs from 'fs-extra';
 import * as path from 'path';
-import checkJwtTokens from '../utility/install/checkJWTTokensExist.js';
+import checkJwtTokens from '../utility/install/checkJWTTokensExist.ts';
 import { install } from '../utility/install/installer.ts';
 import chalk from 'chalk';
 import { packageJson } from '../utility/packageUtils.js';
 import * as hdbUtils from '../utility/common_utils.ts';
 import * as installation from '../utility/installation.ts';
-import * as configUtils from '../config/configUtils.js';
+import * as configUtils from '../config/configUtils.ts';
 import assignCMDENVVariables from '../utility/assignCmdEnvVariables.ts';
-import * as upgrade from './upgrade.js';
+import * as upgrade from './upgrade.ts';
 import { compactOnStart, migrateOnStart } from './copyDb.ts';
 import minimist from 'minimist';
 import * as keys from '../security/keys.ts';
@@ -27,7 +30,7 @@ import * as hdbInfoController from '../dataLayer/hdbInfoController.ts';
 import { isReadOnlyMode } from '../resources/databases.ts';
 import { getThisNodeName } from '../server/nodeName.ts';
 import * as hdbTerms from '../utility/hdbTerms.ts';
-import { getHdbPid, isProcessRunning } from '../utility/processManagement/processManagement.js';
+import { getHdbPid, isProcessRunning } from '../utility/processManagement/processManagement.ts';
 import { PACKAGE_ROOT } from '../utility/packageUtils.js';
 
 let pmUtils;
@@ -108,7 +111,7 @@ async function initialize(calledByInstall = false, calledByMain = false) {
 
 		// If HARPER_SET_CONFIG is present, filter out any config keys that are set in it
 		// to prevent individual env vars from overriding explicit runtime configuration
-		const { filterArgsAgainstRuntimeConfig } = require('../config/harperConfigEnvVars');
+		const { filterArgsAgainstRuntimeConfig } = await import('../config/harperConfigEnvVars.ts');
 		parsedArgs = filterArgsAgainstRuntimeConfig(parsedArgs);
 
 		if (!hdbUtils.isEmpty(parsedArgs) && !hdbUtils.isEmptyOrZeroLength(Object.keys(parsedArgs))) {
@@ -199,6 +202,12 @@ async function main(calledByInstall = false) {
 		}
 		await initialize(calledByInstall, true);
 
+		// Drain onStartup hooks after install/initialize so server.X singletons
+		// (server.http, server.getUser, etc.) and auth.ts's onStartup table()
+		// call see the populated env / installed hdbBasePath.
+		const lifecycle = await import('../utility/lifecycle.ts');
+		await lifecycle.runStartup();
+
 		if (env.get(terms.CONFIG_PARAMS.STORAGE_COMPACTONSTART)) await compactOnStart();
 		if (env.get(terms.CONFIG_PARAMS.STORAGE_MIGRATEONSTART)) await migrateOnStart();
 
@@ -233,7 +242,7 @@ function started() {
 async function launch(exit = true) {
 	skipExitListeners = !exit;
 	try {
-		if (pmUtils === undefined) pmUtils = require('../utility/processManagement/processManagement.js');
+		if (pmUtils === undefined) pmUtils = await import('../utility/processManagement/processManagement.ts');
 		hdbLogger.debug('initializing processManagement...');
 		await initialize();
 		hdbLogger.debug('Starting new main process');

bin/status.ts

@@ -1,6 +1,6 @@
 'use strict';
 
-import * as fs from 'fs-extra';
+import fs from 'fs-extra';
 import * as path from 'path';
 import * as YAML from 'yaml';
 
@@ -9,8 +9,11 @@ import hdbLog from '../utility/logging/harper_logger.ts';
 import * as systemInformation from '../utility/environment/systemInformation.ts';
 import * as envMgr from '../utility/environment/environmentManager.ts';
 import * as installation from '../utility/installation.ts';
-envMgr.initSync();
-
+try {
+	envMgr.initSync();
+} catch {
+	/* tolerate ESM cycle TDZ; bin entry will re-call later */
+}
 const STATUSES = {
 	RUNNING: 'running',
 	STOPPED: 'stopped',

bin/upgrade.js → bin/upgrade.ts

@@ -1,33 +1,28 @@
-'use strict';
-
 /**
  * The upgrade module is used to facilitate the upgrade process for existing instances of HDB that pull down a new version
  * of HDB from NPM that requires a specific upgrade script be run - e.g. there are changes required for the settings.js
  * config file, a data model change requires a re-indexing script is run, etc.
  */
 
-const env = require('../utility/environment/environmentManager.ts');
-env.initSync();
-
-const chalk = require('chalk');
-const hdbLogger = require('../utility/logging/harper_logger.ts');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const directivesManager = require('../upgrade/directivesManager.ts');
-const installation = require('../utility/installation.ts');
-const hdbInfoController = require('../dataLayer/hdbInfoController.ts');
-const upgradePrompt = require('../upgrade/upgradePrompt.ts');
-const globalSchema = require('../utility/globalSchema.ts');
-const { packageJson } = require('../utility/packageUtils.js');
-const promisify = require('util').promisify;
+import * as env from '../utility/environment/environmentManager.ts';
+
+import chalk from 'chalk';
+import _hdbLogger from '../utility/logging/harper_logger.ts';
+const hdbLogger = _hdbLogger;
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as directivesManager from '../upgrade/directivesManager.ts';
+import * as installation from '../utility/installation.ts';
+import * as hdbInfoController from '../dataLayer/hdbInfoController.ts';
+import * as upgradePrompt from '../upgrade/upgradePrompt.ts';
+import * as globalSchema from '../utility/globalSchema.ts';
+import { packageJson } from '../utility/packageUtils.js';
+import { promisify } from 'util';
 const pSchemaToGlobal = promisify(globalSchema.setSchemaDataToGlobal);
 let pm2Utils;
 
 const { UPGRADE_VERSION } = hdbTerms.UPGRADE_JSON_FIELD_NAMES_ENUM;
 
-module.exports = {
-	upgrade,
-};
-
+export { upgrade };
 /**
  * Runs the upgrade directives, if needed, for an updated version of Harper.
  *
@@ -39,7 +34,7 @@ async function upgrade(upgradeObj) {
 
 	// Requiring the processManagement mod will create the .pm2 dir. This code is here to allow install to set
 	// pm2 env vars before that is done.
-	if (pm2Utils === undefined) pm2Utils = require('../utility/processManagement/processManagement.js');
+	if (pm2Utils === undefined) pm2Utils = await import('../utility/processManagement/processManagement.ts');
 
 	//We have to make sure HDB is installed before doing anything else
 	const installed = installation.isHdbInstalled(env, hdbLogger);

components/Application.ts

@@ -1,5 +1,5 @@
 import { type Logger } from '../utility/logging/logger.ts';
-import { getConfigObj, getConfigValue, getConfigPath } from '../config/configUtils.js';
+import { getConfigObj, getConfigValue, getConfigPath } from '../config/configUtils.ts';
 import { CONFIG_PARAMS } from '../utility/hdbTerms.ts';
 import logger from '../utility/logging/harper_logger.ts';
 

components/Component.ts

@@ -1,8 +1,8 @@
-import { resolveBaseURLPath } from './resolveBaseURLPath';
-import { deriveCommonPatternBase } from './deriveCommonPatternBase';
-import { deriveGlobOptions, FastGlobOptions, FilesOption } from './deriveGlobOptions';
-import { scan } from 'micromatch';
-
+import { resolveBaseURLPath } from './resolveBaseURLPath.ts';
+import { deriveCommonPatternBase } from './deriveCommonPatternBase.ts';
+import { deriveGlobOptions, type FastGlobOptions, type FilesOption } from './deriveGlobOptions.ts';
+import _micromatch from 'micromatch';
+const { scan } = _micromatch;
 interface ComponentConfig {
 	files: FilesOption;
 	urlPath?: string;