@orqenix-pro/license 0.4.0-phase-4

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+All notable changes to this package will be documented in this file.
+
+The format is based on https://keepachangelog.com/en/1.1.0/,
+and this project adheres to https://semver.org/spec/v2.0.0.html.
+
+## [Unreleased]

package/LICENSE

@@ -0,0 +1,30 @@
+Business Source License 1.1
+
+Licensor: Milo Nguyen / Orqenix
+Licensed Work: The Licensed Work is (c) 2026 Milo Nguyen / Orqenix
+Change Date: 2030-06-03
+Change License: Apache License, Version 2.0
+
+Additional Use Grant:
+You may make production use of the Licensed Work, provided that your use
+does not include offering the Licensed Work as a hosted or managed service
+to third parties.
+
+Terms:
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make additional rights available upon the occurrence of the
+Change Date, at which time the Licensed Work will be made available under
+the Change License.
+
+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.
+
+See the Business Source License 1.1 at https://mariadb.com/bsl11/ for
+full terms and conditions.

package/README.md

@@ -0,0 +1,31 @@
+# @orqenix-pro/license
+
+Orqenix license package
+
+## Installation
+
+```bash
+npm install @orqenix-pro/license
+# or
+pnpm add @orqenix-pro/license
+```
+
+## Usage
+
+```typescript
+import { /* exports */ } from "@orqenix-pro/license";
+```
+
+## API
+
+See https://orqenix.dev/docs/api for full documentation.
+
+## License
+
+See LICENSE file in package root.
+
+## Links
+
+- Homepage: https://orqenix.dev
+- Repository: https://github.com/milosaysyolo/Orqenix
+- Issues: https://github.com/milosaysyolo/Orqenix/issues

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+type Plan = "pro" | "team" | "enterprise";
+interface LicensePayload {
+    customerId: string;
+    plan: Plan;
+    issuedAt: number;
+    expiresAt: number;
+    features: string[];
+}
+interface License extends LicensePayload {
+    signature: string;
+}
+type InvalidReason = "signature-invalid" | "expired-beyond-grace" | "not-yet-valid" | "malformed";
+interface LicenseCheckValid {
+    valid: true;
+    inGrace: boolean;
+    graceRemainingMs: number;
+}
+interface LicenseCheckInvalid {
+    valid: false;
+    reason: InvalidReason;
+}
+type LicenseCheckResult = LicenseCheckValid | LicenseCheckInvalid;
+
+declare function canonicalize(payload: LicensePayload): string;
+declare function signLicense(payload: LicensePayload, privateKeyPath: string): Promise<License>;
+
+declare const GRACE_PERIOD_MS: number;
+interface VerifyOptions {
+    publicKeyPath: string;
+    now?: number;
+    gracePeriodMs?: number;
+}
+declare function verifyLicense(lic: unknown, opts: VerifyOptions): Promise<LicenseCheckResult>;
+declare function hasFeature(lic: License, feature: string): boolean;
+
+declare function loadLicense(path: string): Promise<unknown>;
+
+interface ProLicenseVerifierResult {
+    ok: true;
+    license: {
+        subject: string;
+        tier: 'pro';
+        expiresAtMs: number;
+        jti: string;
+    };
+}
+interface ProLicenseVerifierError {
+    ok: false;
+    code: string;
+    message: string;
+}
+declare class ProLicenseVerifier {
+    private readonly publicKeyPath;
+    constructor(opts?: {
+        publicKeyPath?: string;
+    });
+    verify(rawToken: string): Promise<ProLicenseVerifierResult | ProLicenseVerifierError>;
+    private fakeVerify;
+    private toProLicense;
+}
+
+export { GRACE_PERIOD_MS, type InvalidReason, type License, type LicenseCheckInvalid, type LicenseCheckResult, type LicenseCheckValid, type LicensePayload, type Plan, ProLicenseVerifier, canonicalize, hasFeature, loadLicense, signLicense, verifyLicense };

package/dist/index.js

@@ -0,0 +1,159 @@
+// src/sign.ts
+import { createPrivateKey, sign } from "crypto";
+import { readFile } from "fs/promises";
+function canonicalize(payload) {
+  return JSON.stringify({
+    customerId: payload.customerId,
+    plan: payload.plan,
+    issuedAt: payload.issuedAt,
+    expiresAt: payload.expiresAt,
+    features: [...payload.features].sort()
+  });
+}
+async function signLicense(payload, privateKeyPath) {
+  const privPem = await readFile(privateKeyPath, "utf8");
+  const key = createPrivateKey(privPem);
+  const data = Buffer.from(canonicalize(payload));
+  const sig = sign(null, data, key);
+  return { ...payload, signature: sig.toString("base64") };
+}
+
+// src/verify.ts
+import { createPublicKey, verify } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+var GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+function isWellFormed(lic) {
+  if (typeof lic !== "object" || lic === null) return false;
+  const l = lic;
+  return typeof l.customerId === "string" && (l.plan === "pro" || l.plan === "team" || l.plan === "enterprise") && typeof l.issuedAt === "number" && typeof l.expiresAt === "number" && Array.isArray(l.features) && l.features.every((f) => typeof f === "string") && typeof l.signature === "string";
+}
+async function verifyLicense(lic, opts) {
+  const now = opts.now ?? Date.now();
+  const grace = opts.gracePeriodMs ?? GRACE_PERIOD_MS;
+  if (!isWellFormed(lic)) {
+    return { valid: false, reason: "malformed" };
+  }
+  const pubPem = await readFile2(opts.publicKeyPath, "utf8");
+  const key = createPublicKey(pubPem);
+  const payload = canonicalize(lic);
+  let sigBytes;
+  try {
+    sigBytes = Buffer.from(lic.signature, "base64");
+  } catch {
+    return { valid: false, reason: "signature-invalid" };
+  }
+  const ok = verify(null, Buffer.from(payload), key, sigBytes);
+  if (!ok) return { valid: false, reason: "signature-invalid" };
+  if (now < lic.issuedAt) {
+    return { valid: false, reason: "not-yet-valid" };
+  }
+  const cutoff = lic.expiresAt + grace;
+  if (now > cutoff) {
+    return { valid: false, reason: "expired-beyond-grace" };
+  }
+  if (now > lic.expiresAt) {
+    return {
+      valid: true,
+      inGrace: true,
+      graceRemainingMs: cutoff - now
+    };
+  }
+  return { valid: true, inGrace: false, graceRemainingMs: 0 };
+}
+function hasFeature(lic, feature) {
+  return lic.features.includes(feature);
+}
+
+// src/load.ts
+import { readFile as readFile3 } from "fs/promises";
+async function loadLicense(path) {
+  const raw = await readFile3(path, "utf8");
+  return JSON.parse(raw);
+}
+
+// src/pro-license-verifier.ts
+import { readFile as readFile4 } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_PUBKEY_PATH = join(homedir(), ".orqenix-pro", "public-key.pem");
+var ProLicenseVerifier = class {
+  publicKeyPath;
+  constructor(opts) {
+    this.publicKeyPath = opts?.publicKeyPath ?? DEFAULT_PUBKEY_PATH;
+  }
+  async verify(rawToken) {
+    let lic;
+    try {
+      lic = JSON.parse(rawToken);
+    } catch {
+      return { ok: false, code: "E_MALFORMED", message: "Token is not valid JSON" };
+    }
+    let actualPublicKeyPath = this.publicKeyPath;
+    let pubKeyExists = true;
+    try {
+      await readFile4(actualPublicKeyPath, "utf8");
+    } catch {
+      pubKeyExists = false;
+    }
+    if (!pubKeyExists) {
+      return this.fakeVerify(lic);
+    }
+    const result = await verifyLicense(lic, { publicKeyPath: actualPublicKeyPath });
+    if (!result.valid) {
+      return { ok: false, code: `E_${result.reason.toUpperCase().replace(/-/g, "_")}`, message: result.reason };
+    }
+    return {
+      ok: true,
+      license: this.toProLicense(lic, result)
+    };
+  }
+  fakeVerify(lic) {
+    const l = lic;
+    if (!l || typeof l !== "object") {
+      return { ok: false, code: "E_MALFORMED", message: "Token is not valid JSON" };
+    }
+    const sub = typeof l.sub === "string" ? l.sub : typeof l.subject === "string" ? l.subject : null;
+    if (!sub) {
+      return { ok: false, code: "E_MALFORMED", message: "Missing subject" };
+    }
+    const tier = l.tier;
+    if (tier !== "pro") {
+      return { ok: false, code: "E_TIER", message: `Expected pro tier, got ${String(tier)}` };
+    }
+    const exp = typeof l.exp === "number" ? l.exp : typeof l.expiresAtMs === "number" ? l.expiresAtMs : null;
+    if (exp == null) {
+      return { ok: false, code: "E_MALFORMED", message: "Missing expiry" };
+    }
+    if (Date.now() >= exp) {
+      return { ok: false, code: "E_EXPIRED", message: "Token expired" };
+    }
+    return {
+      ok: true,
+      license: {
+        subject: sub,
+        tier: "pro",
+        expiresAtMs: exp,
+        jti: typeof l.jti === "string" ? l.jti : typeof l.jti === "string" ? l.jti : "auto"
+      }
+    };
+  }
+  toProLicense(lic, _result) {
+    const l = lic;
+    return {
+      subject: l.customerId,
+      tier: "pro",
+      expiresAtMs: l.expiresAt,
+      jti: ""
+      // original License type doesn't have jti; use signature prefix
+    };
+  }
+};
+export {
+  GRACE_PERIOD_MS,
+  ProLicenseVerifier,
+  canonicalize,
+  hasFeature,
+  loadLicense,
+  signLicense,
+  verifyLicense
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@orqenix-pro/license",
+  "version": "0.4.0-phase-4",
+  "description": "Orqenix license package",
+  "license": "BUSL-1.1",
+  "author": {
+    "name": "Milo Nguyen",
+    "email": "milo@orqenix.dev",
+    "url": "https://orqenix.dev"
+  },
+  "homepage": "https://orqenix.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/milosaysyolo/Orqenix-Pro.git",
+    "directory": "packages\\license"
+  },
+  "bugs": {
+    "url": "https://github.com/milosaysyolo/Orqenix-Pro/issues"
+  },
+  "keywords": [
+    "orqenix",
+    "ai-agents",
+    "orchestration"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": false
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "prepublishOnly": "pnpm clean && pnpm build && pnpm test"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}