chati-dev 4.0.9 → 4.0.11

package/bin/chati.js

@@ -362,7 +362,7 @@ Telemetry:
 
     case 'deactivate': {
       const { runDeactivate } = await import('../src/license/commands.js');
-      runDeactivate(targetDir);
+      await runDeactivate(targetDir);
       break;
     }
 
@@ -370,7 +370,12 @@ Telemetry:
       const licSubCmd = args[1] || 'status';
       if (licSubCmd === 'deactivate') {
         const { runDeactivate } = await import('../src/license/commands.js');
-        runDeactivate(targetDir);
+        await runDeactivate(targetDir);
+      } else if (args.includes('--refresh') || licSubCmd === 'refresh') {
+        // Force re-validate against API and update local cache
+        const { runLicenseStatus } = await import('../src/license/commands.js');
+        await runLicenseStatus(targetDir);
+        console.log('  Cache updated. Hook will use fresh status on next run.\n');
       } else {
         const { runLicenseStatus } = await import('../src/license/commands.js');
         await runLicenseStatus(targetDir);

package/framework/hooks/license-guard.js

@@ -20,6 +20,7 @@ import { homedir } from 'os';
 const API_BASE = 'https://chati.dev/api';
 const TELEMETRY_ENDPOINT = 'https://chati.dev/api/telemetry';
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const PING_THROTTLE_MS = 5 * 60 * 1000; // 5 minutes
 
 const GLOBAL_DIR = join(homedir(), '.chati-dev');
 const LICENSE_PATH = join(GLOBAL_DIR, 'license.yaml');
@@ -97,16 +98,17 @@ async function main() {
 }
 
 // ---------------------------------------------------------------------------
-// Session Ping (once per day per project)
+// Session Ping (5-min throttle with phase-change detection)
 // ---------------------------------------------------------------------------
 
 async function allowWithPing(licenseKey) {
   const projectPath = process.cwd();
   const projectName = basename(projectPath) || 'unknown';
+  const session = readSessionContext();
 
-  if (shouldPing(projectPath)) {
-    recordPing(projectPath); // sync — prevents duplicate pings even if fetch fails
-    const pingPromise = sendSessionPing(licenseKey, projectName);
+  if (shouldPing(projectPath, session)) {
+    recordPing(projectPath, session); // sync — prevents duplicate pings even if fetch fails
+    const pingPromise = sendSessionPing(licenseKey, projectName, session);
     allow();
     await pingPromise; // keep process alive until ping completes (max 3s)
   } else {
@@ -114,41 +116,93 @@ async function allowWithPing(licenseKey) {
   }
 }
 
-function shouldPing(projectPath) {
+/**
+ * Reads .chati/session.yaml from cwd to extract pipeline phase, agent, and project type.
+ * Returns {} on any error (fail silently — this is optional enrichment).
+ */
+function readSessionContext() {
+  try {
+    const sessionPath = join(process.cwd(), '.chati', 'session.yaml');
+    if (!existsSync(sessionPath)) return {};
+    const raw = readFileSync(sessionPath, 'utf-8');
+
+    // project.state → pipeline_phase
+    const stateMatch = raw.match(/^\s+state:\s*(.+)$/m);
+    const pipeline_phase = stateMatch ? stateMatch[1].trim().replace(/^["']|["']$/g, '') : null;
+
+    // current_agent (top-level)
+    const agentMatch = raw.match(/^current_agent:\s*(.+)$/m);
+    const current_agent = agentMatch ? agentMatch[1].trim().replace(/^["']|["']$/g, '') : null;
+
+    // project.type → project_type
+    const typeMatch = raw.match(/^\s+type:\s*(.+)$/m);
+    const project_type = typeMatch ? typeMatch[1].trim().replace(/^["']|["']$/g, '') : null;
+
+    return { pipeline_phase, current_agent, project_type };
+  } catch { return {}; }
+}
+
+/**
+ * Pings.yaml format: '/path/to/project': '2026-03-22T21:00:00.000Z|discover|greenfield-wu'
+ * Ping if: (1) no entry, (2) >5 min ago, OR (3) phase/agent changed
+ */
+function shouldPing(projectPath, session = {}) {
   try {
     if (!existsSync(PINGS_PATH)) return true;
     const content = readFileSync(PINGS_PATH, 'utf-8');
-    const today = new Date().toISOString().substring(0, 10);
     const escaped = projectPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const match = content.match(new RegExp(`^${escaped}:\\s*(.+)$`, 'm'));
-    return !match || match[1].trim() !== today;
+    const match = content.match(new RegExp(`^${escaped}:\\s*'?([^'\\n]+)'?$`, 'm'));
+    if (!match) return true;
+
+    const [timestamp, lastPhase, lastAgent] = match[1].trim().split('|');
+    const age = Date.now() - new Date(timestamp).getTime();
+    if (age > PING_THROTTLE_MS) return true;
+
+    // Phase or agent changed → ping immediately
+    if (session.pipeline_phase && session.pipeline_phase !== lastPhase) return true;
+    if (session.current_agent && session.current_agent !== lastAgent) return true;
+
+    return false;
   } catch { return false; } // fail closed — don't add latency on parse error
 }
 
-function recordPing(projectPath) {
+function recordPing(projectPath, session = {}) {
   try {
     mkdirSync(GLOBAL_DIR, { recursive: true });
-    const today = new Date().toISOString().substring(0, 10);
+    const timestamp = new Date().toISOString();
+    const phase = session.pipeline_phase ?? '';
+    const agent = session.current_agent ?? '';
+    const value = `${timestamp}|${phase}|${agent}`;
+
     let content = existsSync(PINGS_PATH) ? readFileSync(PINGS_PATH, 'utf-8') : '';
     const escaped = projectPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     if (new RegExp(`^${escaped}:`, 'm').test(content)) {
-      content = content.replace(new RegExp(`^(${escaped}:).*$`, 'm'), `$1 ${today}`);
+      content = content.replace(new RegExp(`^(${escaped}:).*$`, 'm'), `$1 '${value}'`);
     } else {
-      content += `${projectPath}: ${today}\n`;
+      content += `${projectPath}: '${value}'\n`;
     }
     writeFileSync(PINGS_PATH, content);
   } catch {} // fail silently
 }
 
-async function sendSessionPing(licenseKey, projectName) {
+async function sendSessionPing(licenseKey, projectName, session = {}) {
   try {
+    const properties = {};
+    if (session.pipeline_phase) properties.pipeline_phase = session.pipeline_phase;
+    if (session.current_agent) properties.current_agent = session.current_agent;
+    if (session.project_type) properties.project_type = session.project_type;
+
     await fetch(TELEMETRY_ENDPOINT, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         license_key: licenseKey,
         project_name: projectName,
-        events: [{ type: 'session_active', timestamp: new Date().toISOString() }],
+        events: [{
+          type: 'session_active',
+          timestamp: new Date().toISOString(),
+          properties,
+        }],
       }),
       signal: AbortSignal.timeout(3000),
     });

package/package.json

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

package/src/license/client.js

@@ -125,10 +125,28 @@ export async function validateLicense(_projectDir) {
 }
 
 /**
- * Remove license locally (does not deactivate machine slot on server).
+ * Remove license locally and deactivate machine slot on server (best-effort).
+ * Fails silently if API is unreachable.
  */
-export function deactivateLicense(_projectDir) {
+export async function deactivateLicense(_projectDir) {
   const data = readGlobal();
+  const key = data.key && data.key !== 'null' ? data.key : null;
+
+  // Best-effort server deactivation (key + machine_id = proof of ownership)
+  if (key) {
+    try {
+      const machineId = getMachineId();
+      await fetch(`${API_BASE}/license/self-deactivate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key, machine_id: machineId }),
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch {
+      // Fail silently — local deactivation still proceeds
+    }
+  }
+
   writeGlobal({
     ...data,
     key: null,

package/src/license/commands.js

@@ -50,15 +50,15 @@ export async function runActivate(projectDir, keyArg) {
 // deactivate
 // ---------------------------------------------------------------------------
 
-export function runDeactivate(projectDir) {
+export async 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`);
+  console.log('Deactivating...');
+  await deactivateLicense(projectDir);
+  console.log(`\n✓ License key removed and machine slot freed.\n`);
 }
 
 // ---------------------------------------------------------------------------
@@ -74,7 +74,7 @@ export async function runLicenseStatus(projectDir) {
     return;
   }
 
-  console.log(`\nChecking license...`);
+  console.log(`\nChecking license (refreshing cache)...`);
 
   let status;
   try {

package/src/telemetry/config.js

@@ -27,7 +27,6 @@ export function getTelemetryConfig(targetDir) {
     enabled: true,
     anonymousId: null,
     endpoint: process.env.CHATI_TELEMETRY_ENDPOINT || 'https://chati.dev/api/telemetry',
-    apiKey: process.env.CHATI_TELEMETRY_KEY || '10b0b54ba4f392fa46379ba778062ab0af5ca61e79609a7dce4aadd660104b56',
   };
 
   if (!existsSync(configPath)) return defaults;
@@ -41,7 +40,6 @@ export function getTelemetryConfig(targetDir) {
       enabled: telemetry.enabled === true,
       anonymousId: telemetry.anonymous_id || null,
       endpoint: telemetry.endpoint || defaults.endpoint,
-      apiKey: telemetry.api_key || defaults.apiKey,
     };
   } catch {
     return defaults;

package/src/telemetry/sender.js

@@ -58,24 +58,26 @@ export async function sendEvents(events, config) {
     events,
   };
 
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000);
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
 
-    await fetch(endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(config.apiKey ? { 'X-Telemetry-Key': config.apiKey } : {}),
-      },
-      body: JSON.stringify(payload),
-      signal: controller.signal,
-    });
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
 
-    clearTimeout(timeout);
-    return true;
-  } catch {
-    // Silently fail — never block user workflow
-    return false;
+      clearTimeout(timeout);
+      if (res.ok || res.status < 500) return true; // 4xx = don't retry
+    } catch {
+      // Network error or timeout — retry if attempts remain
+      if (attempt < 3) {
+        await new Promise(r => setTimeout(r, attempt * 500)); // 500ms, 1000ms
+      }
+    }
   }
+  return false;
 }