@swizzyweb/swerve 0.5.3

package/dist/config/config-parser.js

@@ -0,0 +1,43 @@
+import { readFile } from "fs/promises";
+import path from "path";
+export class SwerveConfigException {
+    message;
+    stack;
+    constructor(message) {
+        this.message = message;
+        this.stack = new Error(message).stack;
+    }
+}
+export class SwerveConfigParser {
+    async parse(configPath) {
+        let actualPath;
+        if (configPath.startsWith(".")) {
+            actualPath = path.join(configPath);
+        }
+        else {
+            actualPath = configPath;
+        }
+        const content = await readFile(actualPath, {
+            encoding: "utf-8",
+        });
+        try {
+            const config = JSON.parse(content);
+            this.validateConfig(config);
+            return config;
+        }
+        catch (e) {
+            throw {
+                message: `Error parsing config, ${e.message}`,
+                stack: e.stack ?? new Error("Error parsing config").stack,
+            };
+        }
+    }
+    validateConfig(config) {
+        if (typeof config.port !== "number") {
+            throw new SwerveConfigException("Invalid port");
+        }
+        if (typeof config.services !== "object") {
+            throw new SwerveConfigException("Invalid services configuration");
+        }
+    }
+}

package/dist/config/config.d.ts

@@ -0,0 +1,15 @@
+export type KeyValue<VALUE> = {
+    [k: string]: VALUE;
+};
+export interface IService {
+    packageName?: string;
+    servicePath?: string;
+    packageJson?: any;
+    logLevel?: string;
+    [key: string]: any;
+}
+export interface IConfig {
+    port?: number;
+    services: KeyValue<IService>;
+    [key: string]: any;
+}

package/dist/config/config.js

@@ -0,0 +1 @@
+export {};

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./config.js";
+export * from "./config-parser.js";

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export * from "./config.js";
+export * from "./config-parser.js";

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./swerve.js";
+export * from "./config/index.js";
+export * from "./utils/index.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./swerve.js";
+export * from "./config/index.js";
+export * from "./utils/index.js";

package/dist/logs/swerve-jmoney-Laptop-16-AMD-Ryzen-7040-Series-2025-08-10-00.log

@@ -0,0 +1,3 @@
+{"label":"jmoney-Laptop-16-AMD-Ryzen-7040-Series:::swerve:121451:swerve:","level":"info","message":"Getting webservice package @swizzyweb/swerve and will run on port 3005","timestamp":"2025-08-11T03:55:34.252Z"}
+{"label":"jmoney-Laptop-16-AMD-Ryzen-7040-Series:::swerve:121451:swerve:","level":"error","message":"Failed to install web service","timestamp":"2025-08-11T03:55:34.253Z"}
+{"label":"jmoney-Laptop-16-AMD-Ryzen-7040-Series:::swerve:121451:swerve:","level":"error","message":"Error occurred initializing service\n Invalid arguments\n TypeError: Invalid arguments\n    at getFullImportPath (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/node_modules/@swizzyweb/swerve-manager/dist/utils/installWebservice.js:54:37)\n    at SwerveManager.installWebService (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/node_modules/@swizzyweb/swerve-manager/dist/swerve.js:150:36)\n    at SwerveManager.runWithArgs (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/node_modules/@swizzyweb/swerve-manager/dist/swerve.js:61:47)\n    at async SwerveManager.run (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/node_modules/@swizzyweb/swerve-manager/dist/swerve.js:24:32)\n    at async runV2 (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/dist/bootstrapDeno.js:24:9)\n    at async run (file:///home/jmoney/repos/BrowserToolkitWorkspace/swerve/dist/bootstrapDeno.js:34:16)","timestamp":"2025-08-11T03:55:34.253Z"}

package/dist/logs/swerve-jmoney-Laptop-16-AMD-Ryzen-7040-Series-2025-08-11-00.log

@@ -0,0 +1,2 @@
+{"label":"jmoney-Laptop-16-AMD-Ryzen-7040-Series:::swerve:121451:swerve:","level":"info","message":"swerveArgs.services.length < 1","timestamp":"2025-08-11T03:55:34.243Z"}
+{"label":"jmoney-Laptop-16-AMD-Ryzen-7040-Series:::swerve:121451:swerve:","level":"error","message":"Exception running v2 TypeError: newWebServices is not iterable (cannot read property undefined)","timestamp":"2025-08-11T03:55:34.254Z"}

package/dist/main.d.ts

@@ -0,0 +1,10 @@
+import { Application } from "@swizzyweb/express";
+import { SwerveArgs, ISwerveManager } from "@swizzyweb/swerve-manager";
+export declare function runV2(): Promise<ISwerveManager>;
+export declare function run(): Promise<ISwerveManager>;
+interface RunWithAppArgs {
+    app: Application;
+    args: SwerveArgs;
+}
+export declare function runWithApp(props: RunWithAppArgs): Promise<any[]>;
+export {};

package/dist/main.js

@@ -0,0 +1,100 @@
+// @ts-ignore
+import express from "@swizzyweb/express";
+import { getArgs, installWebService, SwerveManager, } from "@swizzyweb/swerve-manager";
+import { SwizzyWinstonLogger } from "@swizzyweb/swizzy-web-service";
+import os from "node:os";
+import process from "node:process";
+export async function runV2() {
+    let gLogger = new SwizzyWinstonLogger({
+        port: 0,
+        logLevel: process.env.LOG_LEVEL ?? "info",
+        appDataRoot: ".",
+        appName: `swerve`,
+        ownerName: "swerve",
+        hostName: os.hostname(),
+        pid: process.pid,
+    });
+    const swerveManager = new SwerveManager({});
+    try {
+        const args = await getArgs(process.argv, gLogger);
+        await swerveManager.run({ args });
+        return swerveManager;
+    }
+    catch (e) {
+        gLogger.error(`Exception running v2 ${e}`);
+        throw e;
+    }
+}
+export async function run() {
+    if (true) {
+        return await runV2();
+    }
+    let gLogger = new SwizzyWinstonLogger({
+        port: 0,
+        logLevel: process.env.LOG_LEVEL ?? "info",
+        appDataRoot: ".",
+        appName: `swerve`,
+        hostName: os.hostname(),
+        pid: process.pid,
+    });
+    try {
+        const args = await getArgs(process.argv, gLogger);
+        const app = express();
+        const webServices = await runWithApp({ app, args });
+        const port = args.serviceArgs.port ?? 3005;
+        gLogger.debug(`Starting express app...`);
+        await app.listen(port, (err) => {
+            if (err) {
+                gLogger.log(err);
+            }
+            gLogger.info(`${webServices
+                .map((service) => {
+                return service.name;
+            })
+                .join(",")} running on port ${port}`);
+        });
+    }
+    catch (e) {
+        gLogger.error(`Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`);
+    }
+}
+export async function runWithApp(props) {
+    const { app, args } = props;
+    let gLogger = new SwizzyWinstonLogger({
+        port: 0,
+        logLevel: process.env.LOG_LEVEL ?? "info",
+        appDataRoot: args.appDataRoot,
+        appName: `swerve`,
+        hostName: os.hostname(),
+        pid: process.pid,
+    });
+    try {
+        gLogger = new SwizzyWinstonLogger({
+            logLevel: args.serviceArgs.logLevel ?? process.env.LOG_LEVEL ?? "info",
+            port: args.port,
+            logDir: args.appDataRoot,
+            appName: `swerve`,
+            hostName: os.hostname(),
+            pid: process.pid,
+        });
+        gLogger.debug(`Swerve Args: ${JSON.stringify(args)}`);
+        const PORT = args.port ?? 3005;
+        const webServices = [];
+        for (const serviceEntry of Object.entries(args.services)) {
+            const service = serviceEntry[1];
+            const packageName = service.packageName;
+            const importPathOrName = service.servicePath;
+            const webservice = await installWebService(packageName, importPathOrName, PORT, app, {
+                appDataRoot: args.appDataRoot,
+                ...service,
+                ...service.serviceConfiguration,
+                ...args.serviceArgs,
+            }, gLogger);
+            webServices.push(webservice);
+        }
+        return webServices;
+    }
+    catch (e) {
+        gLogger.error(`Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`);
+    }
+}

package/dist/main.ts

@@ -0,0 +1,129 @@
+// @ts-ignore
+import express, { Application } from "../node_modules/@swizzyweb/express";
+import {
+  getArgs,
+  installWebService,
+  SwerveArgs,
+  ISwerveManager,
+  SwerveManager,
+} from "../node_modules/@swizzyweb/swerve-manager";
+import { SwizzyWinstonLogger } from "../node_modules/@swizzyweb/swizzy-web-service";
+import os from "node:os";
+import process from "node:process";
+
+export async function runV2(): Promise<ISwerveManager> {
+  let gLogger = new SwizzyWinstonLogger({
+    port: 0,
+    logLevel: process.env.LOG_LEVEL ?? "info",
+    appDataRoot: ".",
+    appName: `swerve`,
+    ownerName: "swerve",
+    hostName: os.hostname(),
+    pid: process.pid,
+  });
+
+  const swerveManager: ISwerveManager = new SwerveManager({});
+  try {
+    const args = await getArgs(process.argv, gLogger);
+    await swerveManager.run({ args });
+    return swerveManager;
+  } catch (e) {
+    gLogger.error(`Exception running v2 ${e}`);
+    throw e;
+  }
+}
+export async function run() {
+  if (true) {
+    return await runV2();
+  }
+  let gLogger = new SwizzyWinstonLogger({
+    port: 0,
+    logLevel: process.env.LOG_LEVEL ?? "info",
+    appDataRoot: ".",
+    appName: `swerve`,
+    hostName: os.hostname(),
+    pid: process.pid,
+  });
+
+  try {
+    const args = await getArgs(process.argv, gLogger);
+
+    const app = express();
+    const webServices = await runWithApp({ app, args });
+    const port = args.serviceArgs.port ?? 3005;
+    gLogger.debug(`Starting express app...`);
+    await app.listen(port, (err) => {
+      if (err) {
+        gLogger.log(err);
+      }
+      gLogger.info(
+        `${webServices
+          .map((service) => {
+            return service.name;
+          })
+          .join(",")} running on port ${port}`,
+      );
+    });
+  } catch (e) {
+    gLogger.error(
+      `Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`,
+    );
+  }
+}
+
+interface RunWithAppArgs {
+  app: Application;
+  args: SwerveArgs;
+}
+
+export async function runWithApp(props: RunWithAppArgs) {
+  const { app, args } = props;
+  let gLogger = new SwizzyWinstonLogger({
+    port: 0,
+    logLevel: process.env.LOG_LEVEL ?? "info",
+    appDataRoot: args.appDataRoot,
+    appName: `swerve`,
+    hostName: os.hostname(),
+    pid: process.pid,
+  });
+
+  try {
+    gLogger = new SwizzyWinstonLogger({
+      logLevel: args.serviceArgs.logLevel ?? process.env.LOG_LEVEL ?? "info",
+      port: args.port,
+      logDir: args.appDataRoot,
+      appName: `swerve`,
+      hostName: os.hostname(),
+      pid: process.pid,
+    });
+
+    gLogger.debug(`Swerve Args: ${JSON.stringify(args)}`);
+
+    const PORT = args.port ?? 3005;
+    const webServices = [];
+    for (const serviceEntry of Object.entries(args.services)) {
+      const service = serviceEntry[1];
+      const packageName = service.packageName;
+      const importPathOrName = service.servicePath;
+      const webservice = await installWebService(
+        packageName,
+        importPathOrName,
+        PORT,
+        app,
+        {
+          appDataRoot: args.appDataRoot,
+          ...service,
+          ...service.serviceConfiguration,
+          ...args.serviceArgs,
+        },
+        gLogger,
+      );
+      webServices.push(webservice);
+    }
+    return webServices;
+  } catch (e) {
+    gLogger.error(
+      `Error occurred initializing service\n ${e.message}\n ${e.stack ?? {}}`,
+    );
+  }
+}

package/dist/mainCluster.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mainCluster.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import cluster from "node:cluster";
+import os from "node:os";
+import { run } from "./main.js";
+import process from "node:process";
+import { BrowserLogger } from "@swizzyweb/swizzy-common";
+import { SwizzyWinstonLogger } from "@swizzyweb/swizzy-web-service";
+import { getArgs } from "./utils/index.js";
+/**
+ * extra arg:
+ * numThreads - number, default to num cpu cores from os
+ * */
+async function runCluster() {
+    const args = await getArgs(process.argv, new BrowserLogger());
+    const logger = new SwizzyWinstonLogger({
+        port: args.port,
+        //    appDataRoot: args.appDataRoot,
+        appName: `swerve-root`,
+        hostName: os.hostname(),
+        pid: process.pid,
+    });
+    const numThreads = args.serviceArgs?.numThreads ?? os.availableParallelism();
+    if (cluster.isPrimary) {
+        logger.info(`[ParentThread]: Primary ${process.pid} is running`);
+        logger.info(`[ParentThread]: forking ${numThreads} threads`);
+        // Fork workers.
+        for (let i = 0; i < numThreads; i++) {
+            cluster.fork();
+        }
+        cluster.on("exit", (worker, code, signal) => {
+            logger.info(`[ParentThread]: worker ${worker.process.pid} died with code ${code} and singal ${signal}`);
+        });
+    }
+    else {
+        // Workers can share any TCP connection
+        // In this case it is an HTTP server
+        run();
+        console.log(`Worker ${process.pid} started`);
+    }
+}

package/dist/mainCluster.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import cluster from "node:cluster";
+import http from "node:http";
+import os from "node:os";
+import { run } from "./main.js";
+import process from "node:process";
+import { BrowserLogger } from "@swizzyweb/swizzy-common";
+import { SwizzyWinstonLogger } from "@swizzyweb/swizzy-web-service";
+
+import { getArgs } from "./utils/index.js";
+/**
+ * extra arg:
+ * numThreads - number, default to num cpu cores from os
+ * */
+async function runCluster() {
+  const args = await getArgs(process.argv, new BrowserLogger());
+  const logger = new SwizzyWinstonLogger({
+    port: args.port,
+    //    appDataRoot: args.appDataRoot,
+    appName: `swerve-root`,
+    hostName: os.hostname(),
+    pid: process.pid,
+  });
+  const numThreads = args.serviceArgs?.numThreads ?? os.availableParallelism();
+  if (cluster.isPrimary) {
+    logger.info(`[ParentThread]: Primary ${process.pid} is running`);
+    logger.info(`[ParentThread]: forking ${numThreads} threads`);
+    // Fork workers.
+    for (let i = 0; i < numThreads; i++) {
+      cluster.fork();
+    }
+
+    cluster.on("exit", (worker, code, signal) => {
+      logger.info(
+        `[ParentThread]: worker ${worker.process.pid} died with code ${code} and singal ${signal}`,
+      );
+    });
+  } else {
+    // Workers can share any TCP connection
+    // In this case it is an HTTP server
+
+    run();
+    console.log(`Worker ${process.pid} started`);
+  }
+}

package/dist/swerve.d.ts

@@ -0,0 +1,82 @@
+import { Application } from "@swizzyweb/express";
+import { SwerveArgs } from "./utils/index.js";
+import { AnyServer, IWebService, WebService } from "@swizzyweb/swizzy-web-service";
+import { ILogger } from "@swizzyweb/swizzy-common";
+export interface ISwerveManager {
+    run(request: RunRequest): Promise<RunResponse>;
+    stop(request: StopRequest): Promise<void>;
+    getRunningWebServices(props: GetRunningWebServiceRequest): Promise<GetRunningWebServiceResponse>;
+}
+export interface GetRunningWebServiceRequest {
+}
+export interface GetRunningWebServiceResponse {
+    webServices: {
+        [instanceId: string]: {
+            webService: any;
+            serviceConfig: any;
+        };
+    };
+}
+export declare enum InstanceType {
+    webservice = "webservice",
+    stack = "stack"
+}
+export interface InstanceDetails {
+    instanceType: InstanceType;
+    instanceId: string;
+}
+export interface StopRequest {
+    instanceDetails: InstanceDetails;
+}
+export interface RunRequest {
+    args?: SwerveArgs;
+}
+export interface RunResponse {
+    webServices: WebService<any>[];
+}
+export type Apps = {
+    [key: number]: {
+        app: Application;
+        server?: AnyServer;
+        services: {
+            [instanceId: string]: {
+                webService: IWebService;
+                serviceArgs: SwerveArgs;
+                runRequest: RunRequest;
+            };
+        };
+    };
+};
+export interface SwerveManagerProps {
+    apps?: Apps;
+    webServices?: WebService<any>[];
+}
+export interface WebServiceConfiguration {
+}
+type WebServiceConfigurations = {
+    [instanceId: string]: WebServiceConfiguration;
+};
+export declare class SwerveManager implements ISwerveManager {
+    apps: Apps;
+    webServices: WebService<any>[];
+    configurations: WebServiceConfigurations;
+    constructor(props: SwerveManagerProps);
+    run(request: RunRequest): Promise<RunResponse>;
+    runWithArgs(request: RunRequest): Promise<WebService<any>[]>;
+    private runWithApp;
+    installWebService(props: {
+        serviceKey: string;
+        importPathOrName: string;
+        app: Application;
+        appDataRoot: string;
+        packageName: string;
+        port: number;
+        gLogger: ILogger<any>;
+        serviceArgs: {
+            [key: string]: any;
+        };
+    }): Promise<any>;
+    stop(request: StopRequest): Promise<void>;
+    getRunningWebServices(props: GetRunningWebServiceRequest): Promise<GetRunningWebServiceResponse>;
+}
+export {};