chati-dev 4.0.4 → 4.0.6

package/bin/chati.js

@@ -338,6 +338,11 @@ Intelligence:
   npx chati-dev registry [stats|check]             Entity registry
   npx chati-dev health                             System health check
 
+License:
+  npx chati-dev activate [--key=CHATI-XXXX]        Activate license on this machine
+  npx chati-dev deactivate                         Remove license key locally
+  npx chati-dev license                            Show license status
+
 Telemetry:
   npx chati-dev telemetry                          Show telemetry status
   npx chati-dev telemetry enable                   Enable anonymous telemetry
@@ -347,6 +352,32 @@ Telemetry:
       break;
     }
 
+    case 'activate': {
+      const keyFlag = args.find(a => a.startsWith('--key='));
+      const keyArg = keyFlag ? keyFlag.replace('--key=', '') : null;
+      const { runActivate } = await import('../src/license/commands.js');
+      await runActivate(targetDir, keyArg);
+      break;
+    }
+
+    case 'deactivate': {
+      const { runDeactivate } = await import('../src/license/commands.js');
+      runDeactivate(targetDir);
+      break;
+    }
+
+    case 'license': {
+      const licSubCmd = args[1] || 'status';
+      if (licSubCmd === 'deactivate') {
+        const { runDeactivate } = await import('../src/license/commands.js');
+        runDeactivate(targetDir);
+      } else {
+        const { runLicenseStatus } = await import('../src/license/commands.js');
+        await runLicenseStatus(targetDir);
+      }
+      break;
+    }
+
     default: {
       console.error(`Unknown command: ${command}`);
       console.error("Run 'npx chati-dev --help' for usage.");

package/framework/hooks/license-guard.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * License Guard Hook — UserPromptSubmit
+ *
+ * Validates license status before each user prompt turn.
+ * Uses a 24h cache stored in ~/.chati-dev/license.yaml (global, all projects).
+ *
+ * Behavior:
+ * - No key configured  → allow (orchestrator handles inline activation)
+ * - Cache VALID < 24h  → allow silently
+ * - Cache EXPIRED/INVALID < 24h → block with renewal message
+ * - Cache stale (> 24h) → call API, refresh cache, then allow or block
+ * - API unreachable    → fail open (allow), never block work
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const API_BASE = 'https://chati.dev/api';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+const GLOBAL_DIR = join(homedir(), '.chati-dev');
+const LICENSE_PATH = join(GLOBAL_DIR, 'license.yaml');
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    // Read global license file
+    if (!existsSync(LICENSE_PATH)) {
+      allow(); // No license configured — orchestrator handles inline activation
+      return;
+    }
+
+    const licenseRaw = readFileSync(LICENSE_PATH, 'utf-8');
+    const licenseKey = readYamlField(licenseRaw, 'key');
+
+    if (!licenseKey || licenseKey === 'null') {
+      allow();
+      return;
+    }
+
+    // Check cache validity
+    const status = readYamlField(licenseRaw, 'status');
+    const checkedAt = readYamlField(licenseRaw, 'checked_at');
+    const age = checkedAt ? Date.now() - new Date(checkedAt).getTime() : Infinity;
+
+    if (age < CACHE_TTL_MS) {
+      if (status === 'VALID') { allow(); return; }
+      if (status === 'EXPIRED' || status === 'INVALID') {
+        block(buildMessage(status, readYamlField(licenseRaw, 'reason')));
+        return;
+      }
+    }
+
+    // Cache stale — call API
+    try {
+      const machineId = await computeMachineId();
+      const res = await fetch(
+        `${API_BASE}/license/validate?key=${encodeURIComponent(licenseKey)}&machine_id=${encodeURIComponent(machineId)}`,
+        { signal: AbortSignal.timeout(5000) }
+      );
+      const data = await res.json();
+
+      // Persist updated status (keep existing key)
+      const existing = parseYaml(licenseRaw);
+      const updated = {
+        ...existing,
+        status: data.status,
+        plan: data.plan ?? '',
+        days_remaining: data.days_remaining ?? '',
+        expires_at: data.expires_at ?? '',
+        reason: data.reason ?? '',
+        checked_at: new Date().toISOString(),
+      };
+      mkdirSync(GLOBAL_DIR, { recursive: true });
+      writeFileSync(LICENSE_PATH, dumpYaml(updated));
+
+      if (data.status === 'VALID') { allow(); return; }
+      block(buildMessage(data.status, data.reason));
+    } catch {
+      allow(); // Fail open — API unreachable
+    }
+  } catch {
+    allow(); // Parse error — fail open
+  }
+}
+
+function allow() {
+  process.stdout.write(JSON.stringify({ decision: 'allow' }));
+}
+
+function block(reason) {
+  process.stdout.write(JSON.stringify({ decision: 'block', reason }));
+}
+
+function buildMessage(status, reason) {
+  if (status === 'EXPIRED') {
+    return `chati.dev license expired. Renew at https://chati.dev/pricing\nAfter renewing: npx chati-dev activate --key=YOUR-KEY`;
+  }
+  return `chati.dev license invalid${reason ? ` (${reason})` : ''}.\nRun: npx chati-dev activate --key=YOUR-KEY\nOr visit https://chati.dev/pricing`;
+}
+
+function readYamlField(raw, field) {
+  const match = raw.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+  return match ? match[1].trim().replace(/^["']|["']$/g, '') : null;
+}
+
+/** Minimal YAML object parser for simple key:value files */
+function parseYaml(raw) {
+  const obj = {};
+  for (const line of raw.split('\n')) {
+    const m = line.match(/^(\w+):\s*(.*)$/);
+    if (m) obj[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return obj;
+}
+
+/** Minimal YAML serializer for simple flat objects */
+function dumpYaml(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${k}: ${v == null ? '' : String(v).includes(':') ? `'${v}'` : v}`)
+    .join('\n') + '\n';
+}
+
+async function computeMachineId() {
+  const { createHash } = await import('crypto');
+  const os = await import('os');
+  const ifaces = Object.values(os.networkInterfaces()).flat();
+  const mac = ifaces.find(i => i && !i.internal && i.mac !== '00:00:00:00:00:00')?.mac ?? 'no-mac';
+  const raw = [os.hostname(), os.platform(), os.arch(), os.cpus()[0]?.model ?? '', os.userInfo().username, mac].join('|');
+  return createHash('sha256').update(raw).digest('hex').substring(0, 16);
+}
+
+import { fileURLToPath } from 'url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}

package/framework/hooks/settings.json

@@ -5,6 +5,10 @@
       {
         "matcher": ".*",
         "hooks": [
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/license-guard.js"
+          },
           {
             "type": "command",
             "command": "node chati.dev/hooks/prism-engine.js"

package/framework/orchestrator/chati.md

@@ -18,6 +18,39 @@ You are the **Chati.dev Orchestrator**, the single entry point for the Chati.dev
 
 When the user invokes `/chati`, execute this sequence:
 
+### Pre-Flight: License Check
+
+FIRST — before anything else:
+
+```
+1. Read ~/.chati-dev/license.yaml
+
+If file is MISSING or status = "MISSING":
+  Say:
+    "Welcome to chati.dev! Before we start, I need to activate your license.
+
+    Option 1 — Paste your license key below.
+    Option 2 — Get a free 14-day trial: https://chati.dev/pricing
+
+    Enter your key (or press Enter if you just received one via email):"
+
+  → User provides key
+  → Run: `npx chati-dev activate --key={key}`
+  → Re-read ~/.chati-dev/license.yaml
+  → If status = VALID: "✓ Activated! Let's build." → proceed to Step 1
+  → If error: show error message, ask to try again (max 3 attempts, then stop)
+
+If status = "EXPIRED":
+  Say:
+    "Your chati.dev license has expired.
+    Renew at https://chati.dev/pricing
+    After renewing, run: npx chati-dev activate --key=YOUR-KEY"
+  → STOP. Do not proceed.
+
+If status = "VALID":
+  → Proceed silently. Zero mention of license in normal flow.
+```
+
 ### Step 1: Load Context
 ```
 1. Read .chati/session.yaml

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "4.0.4",
+  "version": "4.0.6",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {

package/src/license/client.js

@@ -0,0 +1,138 @@
+import { homedir } from 'os';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import { getMachineId, getMachineName } from './machine-id.js';
+
+const API_BASE = 'https://chati.dev/api';
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+
+// ---------------------------------------------------------------------------
+// Global storage — ~/.chati-dev/license.yaml
+// One activation covers ALL projects on this machine.
+// ---------------------------------------------------------------------------
+
+export function getGlobalDir() {
+  return join(homedir(), '.chati-dev');
+}
+
+export function getGlobalLicensePath() {
+  return join(getGlobalDir(), 'license.yaml');
+}
+
+function readGlobal() {
+  const p = getGlobalLicensePath();
+  if (!existsSync(p)) return {};
+  try { return yaml.load(readFileSync(p, 'utf-8')) || {}; } catch { return {}; }
+}
+
+function writeGlobal(data) {
+  mkdirSync(getGlobalDir(), { recursive: true });
+  writeFileSync(getGlobalLicensePath(), yaml.dump(data, { lineWidth: -1 }));
+}
+
+// ---------------------------------------------------------------------------
+// Key helpers
+// ---------------------------------------------------------------------------
+
+/** Returns license key or null. projectDir param accepted but unused (global storage). */
+export function getLicenseKey(_projectDir) {
+  const key = readGlobal().key;
+  return key && key !== 'null' ? key : null;
+}
+
+export function setLicenseKey(_projectDir, key) {
+  const data = readGlobal();
+  data.key = key ?? null;
+  writeGlobal(data);
+}
+
+// ---------------------------------------------------------------------------
+// Status cache (stored in same global file)
+// ---------------------------------------------------------------------------
+
+export function getLicenseStatus(_projectDir) {
+  const data = readGlobal();
+  return Object.keys(data).length ? data : null;
+}
+
+export function saveLicenseStatus(_projectDir, status) {
+  const existing = readGlobal();
+  writeGlobal({ ...existing, ...status });
+}
+
+// ---------------------------------------------------------------------------
+// API operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Activate a license key on this machine.
+ * Saves key + status to ~/.chati-dev/license.yaml.
+ * projectDir param accepted but unused.
+ */
+export async function activateLicense(_projectDir, key) {
+  const machineId = getMachineId();
+  const machineName = getMachineName();
+
+  const res = await fetch(`${API_BASE}/license/activate`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ key, machine_id: machineId, machine_name: machineName }),
+    signal: AbortSignal.timeout(10000),
+  });
+
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || 'Activation failed');
+
+  writeGlobal({
+    key,
+    status: 'VALID',
+    plan: data.plan ?? 'trial',
+    days_remaining: data.days_remaining ?? null,
+    expires_at: data.expires_at ?? null,
+    checked_at: new Date().toISOString(),
+  });
+
+  return data;
+}
+
+/**
+ * Validate current license against API and refresh cache.
+ */
+export async function validateLicense(_projectDir) {
+  const key = getLicenseKey();
+  if (!key) return { status: 'MISSING' };
+
+  const machineId = getMachineId();
+  const res = await fetch(
+    `${API_BASE}/license/validate?key=${encodeURIComponent(key)}&machine_id=${encodeURIComponent(machineId)}`,
+    { signal: AbortSignal.timeout(5000) }
+  );
+  const data = await res.json();
+
+  const result = {
+    key,
+    status: data.status,
+    plan: data.plan ?? null,
+    days_remaining: data.days_remaining ?? null,
+    expires_at: data.expires_at ?? null,
+    reason: data.reason ?? null,
+    checked_at: new Date().toISOString(),
+  };
+
+  writeGlobal(result);
+  return result;
+}
+
+/**
+ * Remove license locally (does not deactivate machine slot on server).
+ */
+export function deactivateLicense(_projectDir) {
+  const data = readGlobal();
+  writeGlobal({
+    ...data,
+    key: null,
+    status: 'MISSING',
+    checked_at: new Date().toISOString(),
+  });
+}

package/src/license/commands.js

@@ -0,0 +1,96 @@
+/**
+ * License CLI command handlers.
+ * Used by bin/chati.js for: activate, deactivate, license
+ */
+
+import { text, isCancel } from '@clack/prompts';
+import { activateLicense, deactivateLicense, getLicenseKey, getLicenseStatus, validateLicense } from './client.js';
+
+// ---------------------------------------------------------------------------
+// activate
+// ---------------------------------------------------------------------------
+
+export async function runActivate(projectDir, keyArg) {
+  let key = keyArg;
+
+  if (!key) {
+    const input = await text({
+      message: 'Enter your license key (format: CHATI-XXXX-XXXX-XXXX):',
+      placeholder: 'CHATI-XXXX-XXXX-XXXX',
+      validate(v) {
+        if (!v || !v.trim()) return 'Key is required';
+        if (!v.trim().startsWith('CHATI-')) return 'Key must start with CHATI-';
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      console.log('Activation cancelled.');
+      return;
+    }
+    key = input.trim();
+  }
+
+  console.log(`Activating ${key}...`);
+
+  try {
+    const result = await activateLicense(projectDir, key);
+    const plan = result.plan ?? 'trial';
+    const days = result.days_remaining ?? '?';
+    console.log(`\n✓ Activated! Plan: ${plan} — ${days} day(s) remaining.`);
+    console.log(`  Key saved to chati.dev/config.yaml`);
+    console.log(`  Run /chati to start.\n`);
+  } catch (err) {
+    console.error(`\n✗ Activation failed: ${err.message}`);
+    console.error(`  Visit https://chati.dev/pricing to get a key.\n`);
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// deactivate
+// ---------------------------------------------------------------------------
+
+export function runDeactivate(projectDir) {
+  const key = getLicenseKey(projectDir);
+  if (!key) {
+    console.log('No license key found locally. Nothing to remove.');
+    return;
+  }
+  deactivateLicense(projectDir);
+  console.log(`\n✓ License key removed locally.`);
+  console.log(`  To free up a machine slot, visit https://chati.dev/dashboard\n`);
+}
+
+// ---------------------------------------------------------------------------
+// license status
+// ---------------------------------------------------------------------------
+
+export async function runLicenseStatus(projectDir) {
+  const key = getLicenseKey(projectDir);
+
+  if (!key) {
+    console.log('\nLicense: Not activated');
+    console.log('  Get a free 14-day trial at https://chati.dev/pricing\n');
+    return;
+  }
+
+  console.log(`\nChecking license...`);
+
+  let status;
+  try {
+    status = await validateLicense(projectDir);
+  } catch {
+    // Fallback to cache
+    status = getLicenseStatus(projectDir) ?? { status: 'UNKNOWN' };
+  }
+
+  console.log('\nLicense Status');
+  console.log('='.repeat(30));
+  console.log(`  Key:     ${key}`);
+  console.log(`  Status:  ${status.status}`);
+  if (status.plan) console.log(`  Plan:    ${status.plan}`);
+  if (status.days_remaining != null) console.log(`  Days remaining: ${status.days_remaining}`);
+  if (status.expires_at) console.log(`  Expires: ${status.expires_at}`);
+  if (status.reason) console.log(`  Reason:  ${status.reason}`);
+  console.log();
+}

package/src/license/machine-id.js

@@ -0,0 +1,24 @@
+import os from 'os';
+import crypto from 'crypto';
+
+/**
+ * Generates a stable 16-char machine fingerprint.
+ * Based on: hostname, platform, arch, CPU model, username, MAC address.
+ */
+export function getMachineId() {
+  const ifaces = Object.values(os.networkInterfaces()).flat();
+  const mac = ifaces.find(i => i && !i.internal && i.mac !== '00:00:00:00:00:00')?.mac ?? 'no-mac';
+  const raw = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model ?? '',
+    os.userInfo().username,
+    mac,
+  ].join('|');
+  return crypto.createHash('sha256').update(raw).digest('hex').substring(0, 16);
+}
+
+export function getMachineName() {
+  return os.hostname();
+}

package/src/telemetry/sender.js

@@ -9,7 +9,7 @@
 // Default Endpoint
 // ---------------------------------------------------------------------------
 
-export const DEFAULT_ENDPOINT = 'https://chati-telemetry.vercel.app/api/events';
+export const DEFAULT_ENDPOINT = 'https://chati.dev/api/telemetry';
 
 // ---------------------------------------------------------------------------
 // Sender

package/src/wizard/index.js

@@ -11,6 +11,7 @@ import { initCollector, track as telemetryTrack, flush as telemetryFlush } from
 import { sendEvents } from '../telemetry/sender.js';
 import { getTelemetryConfig } from '../telemetry/config.js';
 import { t } from './i18n.js';
+import { getLicenseKey, activateLicense } from '../license/client.js';
 import { DEFAULT_MCPS } from '../config/mcp-configs.js';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
 
@@ -29,11 +30,14 @@ export async function runWizard(targetDir, options = {}) {
     logoText = 'chati.dev';
   }
 
-  // Step 1: Logo + Language Selection (in English)
+  // Step 1: Logo + License Activation (first thing, before anything else)
   logBanner(logoText, VERSION);
 
   p.intro('Setting up chati.dev');
 
+  await runLicenseActivationStep();
+
+  // Step 2: Language Selection
   const language = options.language || await stepLanguage();
 
   // Step 2: Terms of Use (must accept to continue)
@@ -195,3 +199,37 @@ export async function runWizard(targetDir, options = {}) {
     return { success: false, error: err.message };
   }
 }
+
+async function runLicenseActivationStep() {
+  const existingKey = getLicenseKey();
+  if (existingKey) return; // already activated, proceed silently
+
+  console.log('\n  ┌─ License Activation ─────────────────────────────────────────┐');
+  console.log('  │  Your license key works across ALL projects on this machine.  │');
+  console.log('  │  Get a free 14-day trial at: https://chati.dev/pricing        │');
+  console.log('  └──────────────────────────────────────────────────────────────┘\n');
+
+  const keyInput = await p.text({
+    message: 'Enter your license key (press Enter to skip — activate later with: npx chati-dev activate):',
+    placeholder: 'CHATI-XXXX-XXXX-XXXX',
+  });
+
+  if (p.isCancel(keyInput) || !keyInput?.trim()) {
+    console.log('  Skipped. Run: npx chati-dev activate --key=YOUR-KEY when ready.\n');
+    return;
+  }
+
+  const activateSpinner = createSpinner('Activating license...');
+  activateSpinner.start();
+  try {
+    const result = await activateLicense(null, keyInput.trim());
+    activateSpinner.stop();
+    const plan = result.plan ?? 'trial';
+    const days = result.days_remaining ?? '?';
+    console.log(`  ✓ License activated! Plan: ${plan} — ${days} day(s) remaining.\n`);
+  } catch (err) {
+    activateSpinner.stop();
+    console.log(`  ✗ Activation failed: ${err.message}`);
+    console.log('  Run: npx chati-dev activate --key=YOUR-KEY to try again.\n');
+  }
+}