aw-ecc 1.4.32 → 1.4.47

package/scripts/hooks/aw-usage-telemetry-send.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Detached sender — receives a single usage telemetry event as argv[2],
+ * POSTs it to the telemetry API, then exits.
+ *
+ * Spawned by sendAsync() in aw-usage-telemetry.js with { detached: true }.
+ * This script runs independently after the parent hook process exits.
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+const DEFAULT_URL = 'https://services.leadconnectorhq.com/agentic-workspace/api/telemetry/usage-events';
+const TIMEOUT_MS = 10_000;
+
+function post(url, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const transport = parsed.protocol === 'https:' ? https : http;
+
+    const req = transport.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: TIMEOUT_MS,
+      },
+      (res) => {
+        // Drain response
+        res.resume();
+        res.on('end', () => resolve(res.statusCode));
+      },
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('timeout'));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function main() {
+  const eventJson = process.argv[2];
+  if (!eventJson) {
+    process.exit(0);
+  }
+
+  // Resolve telemetry URL: env var → config file → production default.
+  // Config file fallback covers Cursor GUI which doesn't inherit shell env (Bug #9).
+  let baseUrl = process.env.AW_TELEMETRY_URL;
+  if (!baseUrl) {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const configPath = path.join(process.env.HOME || require('os').homedir(), '.aw', 'telemetry', 'config.json');
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      baseUrl = config.telemetry_url || null;
+    } catch { /* no config file — use default */ }
+  }
+  const url = baseUrl
+    ? `${baseUrl.replace(/\/+$/, '')}/telemetry/usage-events`
+    : DEFAULT_URL;
+
+  try {
+    await post(url, eventJson);
+  } catch (err) {
+    // Non-blocking — log and exit cleanly.
+    process.stderr.write(`[aw-telemetry] send failed: ${err.message}\n`);
+  }
+
+  process.exit(0);
+}
+
+main();

package/scripts/hooks/cost-tracker.js

@@ -13,32 +13,11 @@ const {
   appendFile,
   getClaudeDir,
 } = require('../lib/utils');
+const { estimateCost, toNumber } = require('../lib/aw-pricing');
 
 const MAX_STDIN = 1024 * 1024;
 let raw = '';
 
-function toNumber(value) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : 0;
-}
-
-function estimateCost(model, inputTokens, outputTokens) {
-  // Approximate per-1M-token blended rates. Conservative defaults.
-  const table = {
-    'haiku': { in: 0.8, out: 4.0 },
-    'sonnet': { in: 3.0, out: 15.0 },
-    'opus': { in: 15.0, out: 75.0 },
-  };
-
-  const normalized = String(model || '').toLowerCase();
-  let rates = table.sonnet;
-  if (normalized.includes('haiku')) rates = table.haiku;
-  if (normalized.includes('opus')) rates = table.opus;
-
-  const cost = (inputTokens / 1_000_000) * rates.in + (outputTokens / 1_000_000) * rates.out;
-  return Math.round(cost * 1e6) / 1e6;
-}
-
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', chunk => {
   if (raw.length < MAX_STDIN) {
@@ -60,13 +39,14 @@ process.stdin.on('end', () => {
     const metricsDir = path.join(getClaudeDir(), 'metrics');
     ensureDir(metricsDir);
 
+    const cost = estimateCost(model, inputTokens, outputTokens);
     const row = {
       timestamp: new Date().toISOString(),
       session_id: sessionId,
       model,
       input_tokens: inputTokens,
       output_tokens: outputTokens,
-      estimated_cost_usd: estimateCost(model, inputTokens, outputTokens),
+      estimated_cost_usd: cost,
     };
 
     appendFile(path.join(metricsDir, 'costs.jsonl'), `${JSON.stringify(row)}\n`);

package/scripts/hooks/shared/aw-phase-definitions.js

@@ -1,3 +1,16 @@
+const PHASE_NAMES = Object.freeze({
+  SESSION_START: 'session-start',
+  USER_PROMPT_SUBMIT: 'user-prompt-submit',
+  PRE_TOOL_USE_SHELL: 'pre-tool-use-shell',
+  PRE_TOOL_USE_MCP: 'pre-tool-use-mcp',
+  POST_TOOL_USE_SHELL: 'post-tool-use-shell',
+  POST_TOOL_USE_FILE_EDIT: 'post-tool-use-file-edit',
+  POST_TOOL_USE_MCP: 'post-tool-use-mcp',
+  PRE_COMPACT: 'pre-compact',
+  SESSION_END: 'session-end',
+  STOP: 'stop',
+});
+
 const SHARED_AW_PHASE_STEPS = Object.freeze({
   'session-start': [
     {
@@ -8,6 +21,13 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       payloadMode: 'raw',
       outputMode: 'cursor-session-start',
     },
+    {
+      hookId: 'telemetry:session-start',
+      allowedProfiles: ['minimal', 'standard', 'strict'],
+      runner: 'node',
+      relativeScriptPath: 'scripts/hooks/aw-usage-session-start.js',
+      payloadMode: 'claude',
+    },
   ],
   'user-prompt-submit': [
     {
@@ -15,6 +35,13 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: '.cursor/hooks/shared/user-prompt-submit.sh',
       payloadMode: 'raw',
     },
+    {
+      hookId: 'telemetry:prompt-submit',
+      allowedProfiles: ['minimal', 'standard', 'strict'],
+      runner: 'node',
+      relativeScriptPath: 'scripts/hooks/aw-usage-prompt-submit.js',
+      payloadMode: 'claude',
+    },
   ],
   'pre-tool-use-shell': [
     {
@@ -70,6 +97,13 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: 'scripts/hooks/post-bash-build-complete.js',
       payloadMode: 'claude',
     },
+    {
+      hookId: 'telemetry:post-tool-use',
+      allowedProfiles: ['minimal', 'standard', 'strict'],
+      runner: 'node',
+      relativeScriptPath: 'scripts/hooks/aw-usage-post-tool-use.js',
+      payloadMode: 'claude',
+    },
   ],
   'post-tool-use-file-edit': [
     {
@@ -100,6 +134,13 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: 'scripts/hooks/post-edit-console-warn.js',
       payloadMode: 'claude',
     },
+    {
+      hookId: 'telemetry:post-tool-use',
+      allowedProfiles: ['minimal', 'standard', 'strict'],
+      runner: 'node',
+      relativeScriptPath: 'scripts/hooks/aw-usage-post-tool-use.js',
+      payloadMode: 'claude',
+    },
   ],
   'post-tool-use-mcp': [
     {
@@ -109,6 +150,13 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: 'scripts/hooks/post-mcp-log.js',
       payloadMode: 'raw',
     },
+    {
+      hookId: 'telemetry:post-tool-use',
+      allowedProfiles: ['minimal', 'standard', 'strict'],
+      runner: 'node',
+      relativeScriptPath: 'scripts/hooks/aw-usage-post-tool-use.js',
+      payloadMode: 'claude',
+    },
   ],
   'pre-compact': [
     {
@@ -125,6 +173,8 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: 'scripts/hooks/session-end-marker.js',
       payloadMode: 'claude',
     },
+    // telemetry:session-end removed — afterAgentResponse hook now emits
+    // response_completed per turn with direct token/cost data from Cursor.
   ],
   stop: [
     {
@@ -155,6 +205,8 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       relativeScriptPath: 'scripts/hooks/cost-tracker.js',
       payloadMode: 'claude',
     },
+    // telemetry:stop removed — Cursor fires both sessionEnd and stop,
+    // causing duplicate session_ended events. Telemetry is in session-end phase only.
   ],
 });
 
@@ -167,6 +219,7 @@ function getSharedAwPhaseSteps(phaseName) {
 }
 
 module.exports = {
+  PHASE_NAMES,
   SHARED_AW_PHASE_STEPS,
   getSharedAwPhaseSteps,
 };

package/scripts/hooks/shared/aw-phase-runner.js

@@ -39,7 +39,9 @@ function formatCursorSessionStartOutput(stdout, fallbackRaw) {
     if (typeof additionalContext === 'string' && additionalContext.trim() !== '') {
       return `${JSON.stringify({ additional_context: additionalContext }, null, 2)}\n`;
     }
-  } catch {}
+  } catch (_error) {
+    return fallbackRaw;
+  }
 
   return fallbackRaw;
 }

package/scripts/lib/aw-hook-contract.js

@@ -32,7 +32,7 @@ const AW_HOOK_PHASES = [
     tier: 'core',
     claudeEvent: 'PostToolUse',
     codexEvent: 'PostToolUse',
-    cursorEvents: ['afterShellExecution', 'afterFileEdit', 'afterMCPExecution'],
+    cursorEvents: ['afterShellExecution', 'afterFileEdit', 'afterMCPExecution', 'postToolUse'],
   },
   {
     phase: 'Stop',
@@ -53,7 +53,7 @@ const AW_HOOK_PHASES = [
     tier: 'extended',
     claudeEvent: 'PostToolUseFailure',
     codexEvent: null,
-    cursorEvents: [],
+    cursorEvents: ['postToolUseFailure'],
   },
   {
     phase: 'PreCompact',

package/scripts/lib/aw-pricing.js

@@ -0,0 +1,306 @@
+/**
+ * AW Pricing — dynamic LLM cost estimation.
+ *
+ * Resolution order:
+ *   1. In-process memory cache
+ *   2. Disk cache (~/.aw/telemetry/pricing-cache.json, 24h TTL)
+ *   3. OpenRouter /api/v1/models fetch (3s timeout, no auth)
+ *   4. Hardcoded FALLBACK_PRICING (last resort)
+ *   5. null (model not found anywhere)
+ *
+ * CJS module — consistent with existing aw-ecc hook ecosystem.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+const CACHE_PATH = path.join(os.homedir(), '.aw', 'telemetry', 'pricing-cache.json');
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT = 3000; // 3 seconds
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/models';
+
+// ── Hardcoded fallback (last resort when API + cache both fail) ──────
+
+const FALLBACK_PRICING = {
+  // Anthropic Claude (latest generation pricing)
+  'haiku':   { in: 1.00, out: 5.00 },
+  'sonnet':  { in: 3.00, out: 15.00 },
+  'opus':    { in: 5.00, out: 25.00 },
+  // OpenAI — GPT
+  'gpt-5':        { in: 1.25, out: 10.00 },
+  'gpt-5-mini':   { in: 0.25, out: 2.00 },
+  'gpt-4o':       { in: 2.50, out: 10.00 },
+  'gpt-4o-mini':  { in: 0.15, out: 0.60 },
+  'gpt-4.1':      { in: 2.00, out: 8.00 },
+  'gpt-4.1-mini': { in: 0.40, out: 1.60 },
+  'gpt-4.1-nano': { in: 0.10, out: 0.40 },
+  // OpenAI — reasoning
+  'o1':           { in: 15.00, out: 60.00 },
+  'o1-mini':      { in: 1.10, out: 4.40 },
+  'o3':           { in: 2.00, out: 8.00 },
+  'o3-mini':      { in: 1.10, out: 4.40 },
+  'o4-mini':      { in: 1.10, out: 4.40 },
+  // OpenAI — Codex CLI
+  'codex-mini':       { in: 1.50, out: 6.00 },
+  'codex-1':          { in: 1.50, out: 6.00 },
+  // OpenAI — GPT Codex (agentic coding)
+  'gpt-5.1-codex-mini': { in: 0.25, out: 2.00 },
+  'gpt-5.1-codex':      { in: 1.25, out: 10.00 },
+  'gpt-5.2-codex':      { in: 1.75, out: 14.00 },
+  'gpt-5.3-codex':      { in: 1.75, out: 14.00 },
+  // Google Gemini
+  'gemini-2.5-pro':        { in: 1.25, out: 10.00 },
+  'gemini-2.5-flash':      { in: 0.30, out: 2.50 },
+  'gemini-2.5-flash-lite': { in: 0.10, out: 0.40 },
+};
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function toNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+// ── Memory cache ─────────────────────────────────────────────────────
+
+let _pricingCache = null; // { models: { [key]: { in, out } }, fetched_at: string }
+
+// ── Disk cache ───────────────────────────────────────────────────────
+
+function readDiskCache() {
+  try {
+    const raw = fs.readFileSync(CACHE_PATH, 'utf8');
+    const data = JSON.parse(raw);
+    if (data && data.models && data.fetched_at) {
+      return data;
+    }
+  } catch { /* missing or corrupt — non-blocking */ }
+  return null;
+}
+
+function writeDiskCache(data) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2) + '\n');
+  } catch { /* best effort */ }
+}
+
+function isCacheStale(cacheData) {
+  if (!cacheData || !cacheData.fetched_at) return true;
+  const age = Date.now() - new Date(cacheData.fetched_at).getTime();
+  return age > CACHE_TTL;
+}
+
+// ── OpenRouter fetch ─────────────────────────────────────────────────
+
+function normalizeOpenRouterResponse(data) {
+  const models = {};
+  if (!Array.isArray(data)) return models;
+
+  for (const entry of data) {
+    if (!entry.id || !entry.pricing) continue;
+    const prompt = parseFloat(entry.pricing.prompt);
+    const completion = parseFloat(entry.pricing.completion);
+    if (!Number.isFinite(prompt) || !Number.isFinite(completion)) continue;
+
+    // Per-token → per-1M-token
+    const inRate = prompt * 1_000_000;
+    const outRate = completion * 1_000_000;
+
+    // Store under full OpenRouter id (e.g. "anthropic/claude-3.5-sonnet")
+    models[entry.id] = { in: inRate, out: outRate };
+
+    // Also store under the model slug after the slash (e.g. "claude-3.5-sonnet")
+    const slash = entry.id.indexOf('/');
+    if (slash > 0) {
+      const slug = entry.id.substring(slash + 1);
+      // Don't overwrite if slug already exists (first provider wins)
+      if (!models[slug]) {
+        models[slug] = { in: inRate, out: outRate };
+      }
+    }
+  }
+
+  return models;
+}
+
+/**
+ * Fetch pricing from OpenRouter. Returns a Promise that resolves to
+ * { models, fetched_at } or null on failure.
+ */
+function fetchPricing() {
+  return new Promise((resolve) => {
+    const req = https.get(OPENROUTER_URL, { timeout: FETCH_TIMEOUT }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume(); // drain
+        resolve(null);
+        return;
+      }
+
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          const models = normalizeOpenRouterResponse(json.data);
+          if (Object.keys(models).length === 0) {
+            resolve(null);
+            return;
+          }
+          const cacheData = {
+            fetched_at: new Date().toISOString(),
+            model_count: Object.keys(models).length,
+            models,
+          };
+          resolve(cacheData);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+/**
+ * Non-blocking background refresh. Fetches pricing and updates both
+ * disk and memory caches. Never throws, never blocks the caller.
+ */
+function refreshPricingAsync() {
+  fetchPricing().then((data) => {
+    if (data) {
+      writeDiskCache(data);
+      _pricingCache = data;
+    }
+  }).catch(() => { /* swallow — non-blocking */ });
+}
+
+// ── Load pricing (sync) ─────────────────────────────────────────────
+
+/**
+ * Returns cached pricing data or null. Never fetches synchronously.
+ * Triggers a background refresh when cache is stale.
+ */
+function loadPricingSync() {
+  // 1. Memory cache
+  if (_pricingCache && !isCacheStale(_pricingCache)) {
+    return _pricingCache;
+  }
+
+  // 2. Disk cache
+  const diskData = readDiskCache();
+  if (diskData) {
+    _pricingCache = diskData;
+    if (isCacheStale(diskData)) {
+      // Use stale data now, refresh in background for next time
+      refreshPricingAsync();
+    }
+    return _pricingCache;
+  }
+
+  // 3. No cache at all — trigger background fetch for next time
+  refreshPricingAsync();
+  return null;
+}
+
+// ── Model matching ───────────────────────────────────────────────────
+
+/**
+ * Fuzzy-match a model string against a pricing map.
+ * Tries exact match first, then substring includes.
+ */
+function findRates(model, pricingMap) {
+  if (!model || !pricingMap) return null;
+  const normalized = String(model).toLowerCase();
+
+  // Exact match
+  if (pricingMap[normalized]) return pricingMap[normalized];
+
+  // Match against keys using includes (both directions)
+  for (const [key, rates] of Object.entries(pricingMap)) {
+    const lowerKey = key.toLowerCase();
+    if (normalized.includes(lowerKey) || lowerKey.includes(normalized)) {
+      return rates;
+    }
+  }
+
+  return null;
+}
+
+// ── estimateCost ─────────────────────────────────────────────────────
+
+/**
+ * Estimate the cost in USD for a model call.
+ *
+ * @param {string} model - Model identifier (e.g. "claude-sonnet-4-20250514", "gpt-4o")
+ * @param {number} inputTokens - Total input/prompt token count (includes cache tokens)
+ * @param {number} outputTokens - Output/completion token count
+ * @param {object} [opts] - Optional cache token breakdown
+ * @param {number} [opts.cacheReadTokens]  - Tokens served from cache (billed at ~10% of input rate)
+ * @param {number} [opts.cacheWriteTokens] - Tokens written to cache (billed at ~125% of input rate)
+ * @returns {number|null} Estimated cost in USD, or null if unknown model or no tokens
+ */
+function estimateCost(model, inputTokens, outputTokens, opts) {
+  if (!inputTokens && !outputTokens) return null;
+
+  const cacheRead = (opts && opts.cacheReadTokens) || 0;
+  const cacheWrite = (opts && opts.cacheWriteTokens) || 0;
+
+  function computeCost(rates) {
+    if (!rates) return null;
+    const inRate = rates.in;
+    const outRate = rates.out;
+
+    if (cacheRead || cacheWrite) {
+      const nonCached = Math.max(0, inputTokens - cacheRead - cacheWrite);
+      const cost =
+        (nonCached / 1_000_000) * inRate +
+        (cacheRead / 1_000_000) * (inRate * 0.1) +
+        (cacheWrite / 1_000_000) * (inRate * 1.25) +
+        (outputTokens / 1_000_000) * outRate;
+      return Math.round(cost * 1e6) / 1e6;
+    }
+
+    const cost = (inputTokens / 1_000_000) * inRate + (outputTokens / 1_000_000) * outRate;
+    return Math.round(cost * 1e6) / 1e6;
+  }
+
+  // Try dynamic pricing first (OpenRouter cache)
+  const cached = loadPricingSync();
+  if (cached && cached.models) {
+    const result = computeCost(findRates(model, cached.models));
+    if (result !== null) return result;
+  }
+
+  // Fallback to hardcoded pricing
+  const result = computeCost(findRates(model, FALLBACK_PRICING));
+  if (result !== null) return result;
+
+  // Model not found anywhere
+  return null;
+}
+
+module.exports = {
+  estimateCost,
+  toNumber,
+  loadPricingSync,
+  refreshPricingAsync,
+  FALLBACK_PRICING,
+  // Exposed for testing
+  _test: {
+    readDiskCache,
+    writeDiskCache,
+    isCacheStale,
+    normalizeOpenRouterResponse,
+    findRates,
+    CACHE_PATH,
+    CACHE_TTL,
+  },
+};