ega-v9 1.0.0 → 1.0.2

package/dist/cli/commercial-api-client.d.ts

@@ -0,0 +1,26 @@
+export type EGACommercialUpgradeStatus = "pending" | "approved" | "rejected";
+export type EGACommercialRequestResult = {
+    created: boolean;
+    requestId: string;
+    status: EGACommercialUpgradeStatus;
+};
+export type EGACommercialStatusResult = {
+    requested: boolean;
+    requestId: string | null;
+    status: EGACommercialUpgradeStatus | null;
+    rejectionReason?: string | null;
+    commercialLicenseKey?: string | null;
+};
+export type EGACommercialApiClientOptions = {
+    apiBaseUrl: string;
+    fetchImplementation?: typeof fetch;
+    timeoutMilliseconds?: number;
+};
+export declare class EGACommercialApiError extends Error {
+    readonly code: "EGA_COMMERCIAL_API_CONFIG" | "EGA_COMMERCIAL_API_NETWORK" | "EGA_COMMERCIAL_API_RESPONSE";
+    constructor(code: EGACommercialApiError["code"], message: string);
+}
+export declare function createCommercialApiClient(options: EGACommercialApiClientOptions): {
+    requestUpgrade(licenseKey: string): Promise<EGACommercialRequestResult>;
+    getStatus(licenseKey: string): Promise<EGACommercialStatusResult>;
+};

package/dist/cli/commercial-api-client.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EGACommercialApiError = void 0;
+exports.createCommercialApiClient = createCommercialApiClient;
+class EGACommercialApiError extends Error {
+    constructor(code, message) {
+        super(`[${code}] ${message}`);
+        this.name =
+            "EGACommercialApiError";
+        this.code =
+            code;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.EGACommercialApiError = EGACommercialApiError;
+function normalizeBaseUrl(value) {
+    let url;
+    try {
+        url =
+            new URL(value.trim());
+    }
+    catch {
+        throw new EGACommercialApiError("EGA_COMMERCIAL_API_CONFIG", "Commercial License API URL is invalid.");
+    }
+    if (url.protocol !== "https:" &&
+        !(url.protocol === "http:" &&
+            (url.hostname ===
+                "127.0.0.1" ||
+                url.hostname ===
+                    "localhost"))) {
+        throw new EGACommercialApiError("EGA_COMMERCIAL_API_CONFIG", "Commercial License API must use HTTPS except for localhost development.");
+    }
+    return url
+        .toString()
+        .replace(/\/$/, "");
+}
+function createCommercialApiClient(options) {
+    const baseUrl = normalizeBaseUrl(options.apiBaseUrl);
+    const fetchImplementation = options.fetchImplementation ??
+        fetch;
+    const timeoutMilliseconds = options.timeoutMilliseconds ??
+        10000;
+    async function request(path, method, licenseKey) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMilliseconds);
+        try {
+            let response;
+            try {
+                response =
+                    await fetchImplementation(`${baseUrl}${path}`, {
+                        method,
+                        headers: {
+                            accept: "application/json",
+                            authorization: `Bearer ${licenseKey}`
+                        },
+                        signal: controller.signal
+                    });
+            }
+            catch (error) {
+                throw new EGACommercialApiError("EGA_COMMERCIAL_API_NETWORK", error instanceof Error
+                    ? error.message
+                    : "Unable to contact the Commercial License API.");
+            }
+            let body;
+            try {
+                body =
+                    await response.json();
+            }
+            catch {
+                throw new EGACommercialApiError("EGA_COMMERCIAL_API_RESPONSE", "Commercial License API returned invalid JSON.");
+            }
+            if (!response.ok) {
+                throw new EGACommercialApiError("EGA_COMMERCIAL_API_RESPONSE", body?.error?.message ??
+                    "Commercial License API rejected the request.");
+            }
+            return body;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    return {
+        async requestUpgrade(licenseKey) {
+            return await request("/api/licenses/commercial/request", "POST", licenseKey);
+        },
+        async getStatus(licenseKey) {
+            return await request("/api/licenses/commercial/status", "GET", licenseKey);
+        }
+    };
+}

package/dist/cli/ega-v9.d.ts

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

package/dist/cli/ega-v9.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("readline/promises");
+const process_1 = require("process");
+const register_command_1 = require("./register-command");
+const upgrade_command_1 = require("./upgrade-command");
+const license_api_client_1 = require("./license-api-client");
+const license_key_1 = require("../license/license-key");
+const public_key_1 = require("../license/public-key");
+const license_store_1 = require("../license/license-store");
+function printHelp() {
+    console.log([
+        "EGA V9 CLI",
+        "",
+        "Usage:",
+        "  ega-v9 register",
+        "  ega-v9 upgrade",
+        "  ega-v9 --help",
+        "",
+        "Commands:",
+        "  register    Activate a 90-day Evaluation License",
+        "  upgrade     Request or activate a Commercial License"
+    ].join("\n"));
+}
+async function main() {
+    const command = process.argv[2];
+    if (command === "--help" ||
+        command === "-h" ||
+        !command) {
+        printHelp();
+        return;
+    }
+    if (command === "upgrade") {
+        const exitCode = await (0, upgrade_command_1.runUpgradeCommand)();
+        process.exitCode =
+            exitCode;
+        return;
+    }
+    if (command !== "register") {
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exitCode = 1;
+        return;
+    }
+    const apiBaseUrl = process.env
+        .EGA_V9_LICENSE_API_URL ??
+        "https://lcm3.com";
+    const publicKey = (0, public_key_1.loadEvaluationLicensePublicKey)();
+    const licenseApi = (0, license_api_client_1.createLicenseApiClient)({
+        baseUrl: apiBaseUrl
+    });
+    const readline = (0, promises_1.createInterface)({
+        input: process_1.stdin,
+        output: process_1.stdout
+    });
+    try {
+        await (0, register_command_1.runRegisterCommand)({
+            ask: async (question) => readline.question(question),
+            issueEvaluationLicense: input => licenseApi
+                .issueEvaluationLicense(input),
+            verifyEvaluationLicenseKey: evaluationLicenseKey => (0, license_key_1.verifyEvaluationLicenseKey)(evaluationLicenseKey, publicKey),
+            saveEvaluationLicenseKey: (evaluationLicenseKey, options) => (0, license_store_1.saveEvaluationLicenseKey)(evaluationLicenseKey, options),
+            write: message => console.log(message)
+        });
+    }
+    finally {
+        readline.close();
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error
+        ? error.message
+        : "Unexpected EGA V9 CLI error.");
+    process.exitCode = 1;
+});

package/dist/cli/license-api-client.d.ts

@@ -0,0 +1,20 @@
+import { EGARegistrationInput, EGARegistrationResponse } from "./register-command";
+export type EGALicenseApiClientOptions = {
+    baseUrl: string;
+    timeoutMilliseconds?: number;
+    fetchImplementation?: typeof fetch;
+};
+export declare class EGALicenseApiError extends Error {
+    readonly code: "EGA_LICENSE_API_CONFIG" | "EGA_LICENSE_API_NETWORK" | "EGA_LICENSE_API_RESPONSE";
+    readonly statusCode?: number;
+    readonly remoteCode?: string;
+    constructor(args: {
+        code: EGALicenseApiError["code"];
+        message: string;
+        statusCode?: number;
+        remoteCode?: string;
+    });
+}
+export declare function createLicenseApiClient(options: EGALicenseApiClientOptions): {
+    issueEvaluationLicense(input: EGARegistrationInput): Promise<EGARegistrationResponse>;
+};

package/dist/cli/license-api-client.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EGALicenseApiError = void 0;
+exports.createLicenseApiClient = createLicenseApiClient;
+class EGALicenseApiError extends Error {
+    constructor(args) {
+        super(`[${args.code}] ${args.message}`);
+        this.name =
+            "EGALicenseApiError";
+        this.code =
+            args.code;
+        this.statusCode =
+            args.statusCode;
+        this.remoteCode =
+            args.remoteCode;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.EGALicenseApiError = EGALicenseApiError;
+function normalizeBaseUrl(value) {
+    if (typeof value !== "string" ||
+        value.trim().length === 0) {
+        throw new EGALicenseApiError({
+            code: "EGA_LICENSE_API_CONFIG",
+            message: "The License API base URL is required."
+        });
+    }
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch {
+        throw new EGALicenseApiError({
+            code: "EGA_LICENSE_API_CONFIG",
+            message: "The License API base URL is invalid."
+        });
+    }
+    if (url.protocol !== "https:" &&
+        !(url.protocol === "http:" &&
+            (url.hostname ===
+                "127.0.0.1" ||
+                url.hostname ===
+                    "localhost"))) {
+        throw new EGALicenseApiError({
+            code: "EGA_LICENSE_API_CONFIG",
+            message: "The License API must use HTTPS, except for localhost development."
+        });
+    }
+    return url
+        .toString()
+        .replace(/\/$/, "");
+}
+function createLicenseApiClient(options) {
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const timeoutMilliseconds = options.timeoutMilliseconds ??
+        10000;
+    if (!Number.isInteger(timeoutMilliseconds) ||
+        timeoutMilliseconds < 1) {
+        throw new EGALicenseApiError({
+            code: "EGA_LICENSE_API_CONFIG",
+            message: "timeoutMilliseconds must be a positive integer."
+        });
+    }
+    const fetchImplementation = options.fetchImplementation ??
+        fetch;
+    return {
+        async issueEvaluationLicense(input) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMilliseconds);
+            try {
+                let response;
+                try {
+                    response =
+                        await fetchImplementation(`${baseUrl}/api/licenses/evaluation`, {
+                            method: "POST",
+                            headers: {
+                                "content-type": "application/json",
+                                "accept": "application/json"
+                            },
+                            body: JSON.stringify(input),
+                            signal: controller.signal
+                        });
+                }
+                catch (error) {
+                    throw new EGALicenseApiError({
+                        code: "EGA_LICENSE_API_NETWORK",
+                        message: error instanceof Error
+                            ? error.message
+                            : "Unable to connect to the License API."
+                    });
+                }
+                let body;
+                try {
+                    body =
+                        await response.json();
+                }
+                catch {
+                    throw new EGALicenseApiError({
+                        code: "EGA_LICENSE_API_RESPONSE",
+                        message: "The License API returned invalid JSON.",
+                        statusCode: response.status
+                    });
+                }
+                if (!response.ok) {
+                    const errorBody = body;
+                    throw new EGALicenseApiError({
+                        code: "EGA_LICENSE_API_RESPONSE",
+                        message: errorBody.error?.message ??
+                            "The License API rejected the request.",
+                        statusCode: response.status,
+                        remoteCode: errorBody.error?.code
+                    });
+                }
+                const successBody = body;
+                if (typeof successBody
+                    .evaluationLicenseKey !==
+                    "string" ||
+                    successBody
+                        .evaluationLicenseKey
+                        .trim()
+                        .length === 0) {
+                    throw new EGALicenseApiError({
+                        code: "EGA_LICENSE_API_RESPONSE",
+                        message: "The License API response does not contain an Evaluation License Key.",
+                        statusCode: response.status
+                    });
+                }
+                return {
+                    evaluationLicenseKey: successBody
+                        .evaluationLicenseKey
+                        .trim()
+                };
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+    };
+}

package/dist/cli/register-command.d.ts

@@ -0,0 +1,28 @@
+import { EGAEvaluationLicense } from "../license/types";
+export type EGARegistrationInput = {
+    contactName: string;
+    companyName: string;
+    workEmail: string;
+};
+export type EGARegistrationResponse = {
+    evaluationLicenseKey: string;
+};
+export type EGARegisterCommandDependencies = {
+    ask: (question: string) => Promise<string>;
+    issueEvaluationLicense: (input: EGARegistrationInput) => Promise<EGARegistrationResponse>;
+    verifyEvaluationLicenseKey: (evaluationLicenseKey: string) => EGAEvaluationLicense;
+    saveEvaluationLicenseKey: (evaluationLicenseKey: string, options?: {
+        overwrite?: boolean;
+    }) => string;
+    write: (message: string) => void;
+    overwrite?: boolean;
+};
+export type EGARegisterCommandResult = {
+    license: EGAEvaluationLicense;
+    licensePath: string;
+};
+export declare class EGARegisterCommandError extends Error {
+    readonly code: "EGA_REGISTER_INPUT" | "EGA_REGISTER_SERVICE" | "EGA_REGISTER_RESPONSE";
+    constructor(code: EGARegisterCommandError["code"], message: string);
+}
+export declare function runRegisterCommand(dependencies: EGARegisterCommandDependencies): Promise<EGARegisterCommandResult>;

package/dist/cli/register-command.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EGARegisterCommandError = void 0;
+exports.runRegisterCommand = runRegisterCommand;
+class EGARegisterCommandError extends Error {
+    constructor(code, message) {
+        super(`[${code}] ${message}`);
+        this.name =
+            "EGARegisterCommandError";
+        this.code =
+            code;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.EGARegisterCommandError = EGARegisterCommandError;
+function requireNonEmpty(value, fieldName) {
+    if (typeof value !== "string" ||
+        value.trim().length === 0) {
+        throw new EGARegisterCommandError("EGA_REGISTER_INPUT", `${fieldName} is required.`);
+    }
+    return value.trim();
+}
+function validateWorkEmail(value) {
+    const workEmail = requireNonEmpty(value, "Work Email").toLowerCase();
+    const simpleEmailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!simpleEmailPattern.test(workEmail)) {
+        throw new EGARegisterCommandError("EGA_REGISTER_INPUT", "Work Email must be a valid email address.");
+    }
+    return workEmail;
+}
+function formatDate(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return value;
+    }
+    return date
+        .toISOString()
+        .slice(0, 10);
+}
+function calculateDaysRemaining(expiresAt, now = new Date()) {
+    const expirationDate = new Date(expiresAt);
+    if (Number.isNaN(expirationDate.getTime())) {
+        return 0;
+    }
+    const dayMilliseconds = 24 * 60 * 60 * 1000;
+    return Math.max(0, Math.ceil((expirationDate.getTime() -
+        now.getTime()) /
+        dayMilliseconds));
+}
+async function runRegisterCommand(dependencies) {
+    dependencies.write("");
+    dependencies.write("Welcome to EGA V9");
+    dependencies.write("");
+    dependencies.write("Activate your 90-day Evaluation License.");
+    dependencies.write("No credit card required.");
+    dependencies.write("");
+    const contactName = requireNonEmpty(await dependencies.ask("Contact Name: "), "Contact Name");
+    const companyName = requireNonEmpty(await dependencies.ask("Company Name: "), "Company Name");
+    const workEmail = validateWorkEmail(await dependencies.ask("Work Email: "));
+    let response;
+    try {
+        response =
+            await dependencies
+                .issueEvaluationLicense({
+                contactName,
+                companyName,
+                workEmail
+            });
+    }
+    catch (error) {
+        throw new EGARegisterCommandError("EGA_REGISTER_SERVICE", `Unable to activate the Evaluation License: ${error instanceof Error
+            ? error.message
+            : "unknown service error"}`);
+    }
+    if (!response ||
+        typeof response.evaluationLicenseKey !==
+            "string" ||
+        response.evaluationLicenseKey.trim()
+            .length === 0) {
+        throw new EGARegisterCommandError("EGA_REGISTER_RESPONSE", "The License Service returned an invalid Evaluation License Key.");
+    }
+    const evaluationLicenseKey = response.evaluationLicenseKey.trim();
+    const license = dependencies
+        .verifyEvaluationLicenseKey(evaluationLicenseKey);
+    const licensePath = dependencies
+        .saveEvaluationLicenseKey(evaluationLicenseKey, {
+        overwrite: dependencies.overwrite ??
+            false
+    });
+    dependencies.write("");
+    dependencies.write("✓ Evaluation License Activated");
+    dependencies.write("");
+    dependencies.write(`Issued: ${formatDate(license.issuedAt)}`);
+    dependencies.write(`Expires: ${formatDate(license.expiresAt)}`);
+    dependencies.write(`Days Remaining: ${calculateDaysRemaining(license.expiresAt)}`);
+    dependencies.write("");
+    dependencies.write(`License stored: ${licensePath}`);
+    dependencies.write("");
+    dependencies.write("Happy Building.");
+    return {
+        license,
+        licensePath
+    };
+}

package/dist/cli/upgrade-command.d.ts

@@ -0,0 +1,5 @@
+export type EGAUpgradeCommandOptions = {
+    apiBaseUrl?: string;
+    writeLine?: (value: string) => void;
+};
+export declare function runUpgradeCommand(options?: EGAUpgradeCommandOptions): Promise<number>;

package/dist/cli/upgrade-command.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpgradeCommand = runUpgradeCommand;
+const license_key_1 = require("../license/license-key");
+const license_store_1 = require("../license/license-store");
+const public_key_1 = require("../license/public-key");
+const commercial_api_client_1 = require("./commercial-api-client");
+async function runUpgradeCommand(options = {}) {
+    const writeLine = options.writeLine ??
+        console.log;
+    const installedLicenseKey = (0, license_store_1.readEvaluationLicenseKey)();
+    if (!installedLicenseKey) {
+        writeLine("No EGA V9 License Key is installed.");
+        writeLine("Run `npx ega-v9 register` first.");
+        return 1;
+    }
+    const apiBaseUrl = options.apiBaseUrl ??
+        process.env
+            .EGA_V9_LICENSE_API_URL;
+    if (!apiBaseUrl) {
+        writeLine("EGA V9 License Service URL is not configured.");
+        return 1;
+    }
+    const client = (0, commercial_api_client_1.createCommercialApiClient)({
+        apiBaseUrl
+    });
+    try {
+        const currentStatus = await client.getStatus(installedLicenseKey);
+        if (currentStatus.status ===
+            "approved" &&
+            currentStatus
+                .commercialLicenseKey) {
+            const commercialLicense = (0, license_key_1.verifyLicenseKey)(currentStatus
+                .commercialLicenseKey, (0, public_key_1.loadEvaluationLicensePublicKey)());
+            if (commercialLicense
+                .licenseKind !==
+                "commercial") {
+                throw new Error("The returned License is not Commercial.");
+            }
+            (0, license_store_1.saveEvaluationLicenseKey)(currentStatus
+                .commercialLicenseKey, {
+                overwrite: true
+            });
+            writeLine("");
+            writeLine("✓ Commercial License Activated");
+            writeLine("");
+            writeLine(`Company: ${commercialLicense.companyName}`);
+            writeLine(`License ID: ${commercialLicense.licenseId}`);
+            writeLine(`Issued: ${commercialLicense.issuedAt.slice(0, 10)}`);
+            writeLine(commercialLicense.expiresAt
+                ? `Expires: ${commercialLicense.expiresAt.slice(0, 10)}`
+                : "Expires: No fixed expiration");
+            return 0;
+        }
+        if (currentStatus.status ===
+            "pending") {
+            writeLine("");
+            writeLine("Commercial License request is under review.");
+            writeLine(`Request ID: ${currentStatus.requestId}`);
+            writeLine("");
+            writeLine("Run `npx ega-v9 upgrade` again after LCM confirms your Commercial agreement.");
+            return 0;
+        }
+        if (currentStatus.status ===
+            "rejected") {
+            writeLine("");
+            writeLine("Commercial License request was not approved.");
+            if (currentStatus
+                .rejectionReason) {
+                writeLine(`Reason: ${currentStatus.rejectionReason}`);
+            }
+            return 1;
+        }
+        const requestResult = await client.requestUpgrade(installedLicenseKey);
+        writeLine("");
+        writeLine("✓ Commercial License Request Submitted");
+        writeLine("");
+        writeLine(`Request ID: ${requestResult.requestId}`);
+        writeLine("Status: Pending LCM review");
+        writeLine("");
+        writeLine("LCM will contact your registered Work Email regarding the Commercial agreement.");
+        return 0;
+    }
+    catch (error) {
+        writeLine(error instanceof Error
+            ? error.message
+            : "Unable to process the Commercial License request.");
+        return 1;
+    }
+}

package/dist/index.d.ts

@@ -185,4 +185,5 @@ declare function createGuard(options?: EGAGuardOptions): (req: EGAGuardRequest,
 export declare const ega: Readonly<{
     guard: typeof createGuard;
 }>;
-export {};
+export { EGARuntimeAdmissionError, assertRuntimeLicenseAdmission, evaluateRuntimeAdmission } from "./license/runtime-admission";
+export type { EGARuntimeAdmissionDecision, EGARuntimeAdmissionDependencies, EGARuntimeAdmissionReason } from "./license/runtime-admission";