vektor-slipstream 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vektor-slipstream",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Hardware-accelerated persistent memory for AI agents. Local-first, zero cloud dependency, $0 embedding cost.",
   "main": "slipstream-core.js",
   "exports": {
@@ -9,9 +9,21 @@
     "./embedder": "./slipstream-embedder.js"
   },
   "keywords": [
-    "ai", "memory", "agent", "vector", "sqlite", "embeddings",
-    "langchain", "openai", "anthropic", "claude", "mcp",
-    "rag", "persistent-memory", "local-ai", "onnx"
+    "ai",
+    "memory",
+    "agent",
+    "vector",
+    "sqlite",
+    "embeddings",
+    "langchain",
+    "openai",
+    "anthropic",
+    "claude",
+    "mcp",
+    "rag",
+    "persistent-memory",
+    "local-ai",
+    "onnx"
   ],
   "author": "VEKTOR Memory <hello@vektormemory.com>",
   "license": "SEE LICENSE IN LICENSE",
@@ -28,15 +40,16 @@
     "onnxruntime-node": "^1.17.3"
   },
   "optionalDependencies": {
-    "sqlite-vec-windows-x64": "^0.1.6",
     "sqlite-vec-darwin-arm64": "^0.1.6",
-    "sqlite-vec-linux-x64": "^0.1.6"
+    "sqlite-vec-linux-x64": "^0.1.6",
+    "sqlite-vec-windows-x64": "^0.1.6"
   },
   "files": [
     "slipstream-core.js",
     "slipstream-db.js",
     "slipstream-embedder.js",
     "detect-hardware.js",
+    "vektor-licence.js",
     "models/model_quantized.onnx",
     "examples/",
     "README.md",

package/slipstream-core.js

@@ -18,6 +18,7 @@
 const { initSlipstreamDB, getDBStats }  = require('./slipstream-db');
 const { SlipstreamEmbedder }            = require('./slipstream-embedder');
 const { getEPLabel }                    = require('./detect-hardware');
+const { validateLicence }               = require('./vektor-licence');
 
 // ─── Boot Banner ──────────────────────────────────────────────────────────────
 
@@ -305,11 +306,15 @@ async function createMemory(options = {}) {
   const bootStart = Date.now();
 
   const {
-    agentId  = 'default',
-    dbPath   = './slipstream-memory.db',
-    silent   = false,
+    agentId    = 'default',
+    dbPath     = './slipstream-memory.db',
+    silent     = false,
+    licenceKey = process.env.VEKTOR_LICENCE_KEY || '',
   } = options;
 
+  // 0. Validate Polar licence key
+  await validateLicence(licenceKey);
+
   // 1. Init embedder (hardware probe + ONNX load + pre-warmer)
   const embedder = new SlipstreamEmbedder();
   await embedder.init();

package/vektor-licence.js

@@ -0,0 +1,191 @@
+'use strict';
+/**
+ * vektor-licence.js — Polar Licence Enforcement
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Validates a Polar licence key before allowing createMemory() to proceed.
+ *
+ * Flow:
+ *   1. Customer calls createMemory({ licenceKey: 'VEKTOR-XXXX-...' })
+ *   2. We check ~/.vektor/licence.json for a cached validation (30-day TTL)
+ *   3. If cache miss or expired → call Polar validate API
+ *   4. Valid → cache result, proceed
+ *   5. Invalid/missing → throw with purchase link
+ *
+ * Polar validate endpoint requires no auth token — safe for client-side use.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const crypto = require('crypto');
+
+// ── Config ────────────────────────────────────────────────────────────────────
+// Replace POLAR_ORG_ID with your actual Polar organisation ID from
+// polar.sh → Settings → Organisation ID
+
+const POLAR_ORG_ID    = 'a922049c-3049-41e8-9b20-b18890576b6f';
+const POLAR_API       = 'https://api.polar.sh/v1/customer-portal/license-keys/validate';
+const CACHE_TTL_MS    = 30 * 24 * 60 * 60 * 1000; // 30 days
+const CACHE_DIR       = path.join(os.homedir(), '.vektor');
+const CACHE_FILE      = path.join(CACHE_DIR, 'licence.json');
+const PURCHASE_URL    = 'https://vektormemory.com/#pricing';
+
+// ── Cache helpers ─────────────────────────────────────────────────────────────
+
+function _cacheKey(licenceKey) {
+  // Hash the key so we don't store it in plaintext
+  return crypto.createHash('sha256').update(licenceKey).digest('hex').slice(0, 16);
+}
+
+function _readCache() {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return {};
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+  } catch(_) { return {}; }
+}
+
+function _writeCache(licenceKey, data) {
+  try {
+    if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
+    const cache = _readCache();
+    cache[_cacheKey(licenceKey)] = { ...data, cached_at: Date.now() };
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch(_) {}
+}
+
+function _getCached(licenceKey) {
+  const cache = _readCache();
+  const entry = cache[_cacheKey(licenceKey)];
+  if (!entry) return null;
+  if (Date.now() - entry.cached_at > CACHE_TTL_MS) return null; // expired
+  return entry;
+}
+
+// ── Polar validation ──────────────────────────────────────────────────────────
+
+async function _validateWithPolar(licenceKey) {
+  const body = JSON.stringify({
+    key:             licenceKey,
+    organization_id: POLAR_ORG_ID,
+  });
+
+  const res = await fetch(POLAR_API, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+    signal:  AbortSignal.timeout(10000),
+  });
+
+  if (res.status === 404) {
+    return { valid: false, reason: 'Key not found' };
+  }
+  if (res.status === 422) {
+    return { valid: false, reason: 'Invalid key format' };
+  }
+  if (!res.ok) {
+    // Network/server error — allow offline grace period
+    return { valid: null, reason: `Polar API error: ${res.status}` };
+  }
+
+  const data = await res.json();
+
+  // Polar returns status: 'granted' | 'revoked' | 'disabled'
+  if (data.status !== 'granted') {
+    return { valid: false, reason: `Licence ${data.status}` };
+  }
+
+  return {
+    valid:      true,
+    status:     data.status,
+    expires_at: data.expires_at || null,
+    key_id:     data.id,
+  };
+}
+
+// ── Main export ───────────────────────────────────────────────────────────────
+
+/**
+ * validateLicence(licenceKey)
+ *
+ * Call before createMemory(). Throws if the key is invalid.
+ * Caches valid keys for 30 days so it doesn't call Polar on every run.
+ *
+ * @param {string} licenceKey  — the customer's Polar licence key
+ * @returns {Promise<void>}
+ * @throws {Error} if key is invalid, revoked, or missing
+ */
+async function validateLicence(licenceKey) {
+  if (!licenceKey || typeof licenceKey !== 'string' || licenceKey.trim().length < 8) {
+    throw new Error(
+      '\n' +
+      '  ╔══════════════════════════════════════════════════════╗\n' +
+      '  ║         VEKTOR SLIPSTREAM — LICENCE REQUIRED         ║\n' +
+      '  ╚══════════════════════════════════════════════════════╝\n' +
+      '\n' +
+      '  A valid licence key is required to use Vektor Slipstream.\n' +
+      '\n' +
+      '  Purchase at: ' + PURCHASE_URL + '\n' +
+      '\n' +
+      '  Usage:\n' +
+      '    const memory = await createMemory({\n' +
+      '      agentId:    \'my-agent\',\n' +
+      '      licenceKey: \'VEKTOR-XXXX-XXXX-XXXX\',\n' +
+      '    });\n'
+    );
+  }
+
+  // Check cache first
+  const cached = _getCached(licenceKey);
+  if (cached?.valid === true) {
+    // Cache hit — valid, proceed silently
+    return;
+  }
+
+  // Cache miss or expired — validate with Polar
+  let result;
+  try {
+    result = await _validateWithPolar(licenceKey.trim());
+  } catch(e) {
+    // Network failure — check if we have any cached entry (even expired) as grace period
+    const staleCache = _readCache()[_cacheKey(licenceKey)];
+    if (staleCache?.valid === true) {
+      console.warn('[SLIPSTREAM] Could not reach licence server — using cached validation (grace period).');
+      return;
+    }
+    throw new Error(
+      '[SLIPSTREAM] Licence validation failed — could not reach Polar.\n' +
+      'Check your internet connection and try again.\n' +
+      'Error: ' + e.message
+    );
+  }
+
+  if (result.valid === null) {
+    // Polar API error — use stale cache as grace period
+    const staleCache = _readCache()[_cacheKey(licenceKey)];
+    if (staleCache?.valid === true) {
+      console.warn('[SLIPSTREAM] Licence server error — using cached validation (grace period).');
+      return;
+    }
+    throw new Error('[SLIPSTREAM] Licence server temporarily unavailable. Try again in a moment.');
+  }
+
+  if (!result.valid) {
+    throw new Error(
+      '\n' +
+      '  ╔══════════════════════════════════════════════════════╗\n' +
+      '  ║       VEKTOR SLIPSTREAM — LICENCE INVALID            ║\n' +
+      '  ╚══════════════════════════════════════════════════════╝\n' +
+      '\n' +
+      '  Reason: ' + result.reason + '\n' +
+      '\n' +
+      '  Purchase a valid licence at: ' + PURCHASE_URL + '\n' +
+      '  Already purchased? Check your email for the key.\n'
+    );
+  }
+
+  // Valid — cache it
+  _writeCache(licenceKey, result);
+}
+
+module.exports = { validateLicence };