vibeusage 0.2.19 → 0.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeusage",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/commands/sync.js

@@ -123,6 +123,17 @@ async function cmdSync(argv) {
       });
     }
 
+    const openclawFallback = await applyOpenclawTotalsFallback({
+      trackerDir,
+      signal: openclawSignal,
+      cursors,
+      queuePath,
+      projectQueuePath
+    });
+    openclawResult.filesProcessed += openclawFallback.filesProcessed;
+    openclawResult.eventsAggregated += openclawFallback.eventsAggregated;
+    openclawResult.bucketsQueued += openclawFallback.bucketsQueued;
+
     const claudeFiles = await listClaudeProjectFiles(claudeProjectsDir);
     let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (claudeFiles.length > 0) {
@@ -432,10 +443,123 @@ function resolveOpenclawSignal({ home, env } = {}) {
   const openclawHome = normalizeString(env.VIBEUSAGE_OPENCLAW_HOME) || path.join(home || os.homedir(), '.openclaw');
   const sessionFile = path.join(openclawHome, 'agents', agentId, 'sessions', `${sessionId}.jsonl`);
 
-  return { agentId, sessionId, openclawHome, sessionFile };
+  const prevTotals = {
+    totalTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_TOTAL_TOKENS),
+    inputTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_INPUT_TOKENS),
+    outputTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_OUTPUT_TOKENS),
+    model: normalizeString(env.VIBEUSAGE_OPENCLAW_PREV_MODEL),
+    updatedAt: normalizeIsoOrEpoch(env.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT)
+  };
+
+  return {
+    agentId,
+    sessionId,
+    sessionKey: normalizeString(env.VIBEUSAGE_OPENCLAW_SESSION_KEY),
+    openclawHome,
+    sessionFile,
+    prevTotals
+  };
 }
 
 
+async function applyOpenclawTotalsFallback({ trackerDir, signal, cursors, queuePath, projectQueuePath }) {
+  const totalTokens = Number(signal?.prevTotals?.totalTokens || 0);
+  if (!trackerDir || !signal || totalTokens <= 0) {
+    return { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  const sessionKey = `${signal.agentId}:${signal.sessionId}`;
+  const statePath = path.join(trackerDir, 'openclaw.fallback.state.json');
+  const fallbackFilePath = path.join(trackerDir, 'openclaw.fallback.jsonl');
+  const state = (await readJson(statePath)) || { version: 1, sessions: {} };
+  const sessions = state.sessions && typeof state.sessions === 'object' ? state.sessions : {};
+  const prev = sessions[sessionKey] && typeof sessions[sessionKey] === 'object' ? sessions[sessionKey] : null;
+
+  const current = {
+    totalTokens: normalizeNonNegativeInt(signal?.prevTotals?.totalTokens) || 0,
+    inputTokens: normalizeNonNegativeInt(signal?.prevTotals?.inputTokens) || 0,
+    outputTokens: normalizeNonNegativeInt(signal?.prevTotals?.outputTokens) || 0,
+    model: normalizeString(signal?.prevTotals?.model) || 'unknown',
+    updatedAt: normalizeIsoOrEpoch(signal?.prevTotals?.updatedAt) || new Date().toISOString(),
+    seenAt: new Date().toISOString()
+  };
+
+  let deltaTotal = current.totalTokens;
+  let deltaInput = current.inputTokens;
+  let deltaOutput = current.outputTokens;
+  if (prev) {
+    deltaTotal = Math.max(0, current.totalTokens - (normalizeNonNegativeInt(prev.totalTokens) || 0));
+    deltaInput = Math.max(0, current.inputTokens - (normalizeNonNegativeInt(prev.inputTokens) || 0));
+    deltaOutput = Math.max(0, current.outputTokens - (normalizeNonNegativeInt(prev.outputTokens) || 0));
+  }
+
+  if (deltaTotal > 0 && deltaInput + deltaOutput === 0) {
+    deltaInput = deltaTotal;
+  }
+
+  sessions[sessionKey] = current;
+  state.version = 1;
+  state.sessions = sessions;
+
+  if (deltaTotal <= 0) {
+    await writeJson(statePath, state);
+    return { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  await ensureDir(path.dirname(fallbackFilePath));
+  const syntheticMessage = {
+    type: 'message',
+    timestamp: current.updatedAt,
+    message: {
+      role: 'assistant',
+      model: current.model,
+      usage: {
+        input: deltaInput,
+        output: deltaOutput,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: deltaTotal
+      }
+    }
+  };
+  await fs.appendFile(fallbackFilePath, `${JSON.stringify(syntheticMessage)}\n`, 'utf8');
+  await writeJson(statePath, state);
+
+  return parseOpenclawIncremental({
+    sessionFiles: [{ path: fallbackFilePath, source: 'openclaw' }],
+    cursors,
+    queuePath,
+    projectQueuePath,
+    source: 'openclaw'
+  });
+}
+
+function normalizeNonNegativeInt(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.floor(n);
+}
+
+function normalizeIsoOrEpoch(value) {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (trimmed.length > 0 && !Number.isNaN(Date.parse(trimmed))) return trimmed;
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric) && numeric > 0) {
+      const ms = numeric < 1e12 ? Math.floor(numeric * 1000) : Math.floor(numeric);
+      const iso = new Date(ms).toISOString();
+      if (!Number.isNaN(Date.parse(iso))) return iso;
+    }
+  }
+
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);
+  const dt = new Date(ms);
+  if (Number.isNaN(dt.getTime())) return null;
+  return dt.toISOString();
+}
+
 async function safeStatSize(p) {
   try {
     const st = await fs.stat(p);

package/src/lib/openclaw-hook.js

@@ -252,12 +252,12 @@ function buildHookMarkdown() {
 name: ${OPENCLAW_HOOK_NAME}
 description: "Trigger vibeusage sync when OpenClaw sessions roll over"
 metadata:
-  { "openclaw": { "emoji": "📈", "events": ["command:new", "command:stop"], "requires": { "bins": ["node"] } } }
+  { "openclaw": { "emoji": "📈", "events": ["command:new", "command:reset", "command:stop"], "requires": { "bins": ["node"] } } }
 ---
 
 # VibeUsage OpenClaw Sync Hook
 
-Triggers non-blocking 'vibeusage sync --auto --from-openclaw' runs when OpenClaw command events indicate a session rollover/stop.
+Triggers non-blocking 'vibeusage sync --auto --from-openclaw' runs when OpenClaw command events indicate session rollover/reset/stop.
 `;
 }
 
@@ -281,13 +281,14 @@ function buildHookHandler({ trackerDir, packageName = 'vibeusage', openclawHome
     `module.exports = async function handler(event) {\n` +
     `  try {\n` +
     `    if (!event || event.type !== 'command') return;\n` +
-    `    if (event.action !== 'new' && event.action !== 'stop') return;\n` +
+    `    if (event.action !== 'new' && event.action !== 'reset' && event.action !== 'stop') return;\n` +
     `\n` +
     `    const sessionKey = normalize(event.sessionKey);\n` +
     `    const agentId = parseAgentId(sessionKey);\n` +
     `    if (!agentId) return;\n` +
     `\n` +
-    `    const sessionId = resolveSessionId(event);\n` +
+    `    const sessionEntry = resolveSessionEntry(event);\n` +
+    `    const sessionId = normalize(sessionEntry && sessionEntry.sessionId) || resolveSessionId(event);\n` +
     `    if (!sessionId) return;\n` +
     `\n` +
     `    const now = Date.now();\n` +
@@ -302,9 +303,20 @@ function buildHookHandler({ trackerDir, packageName = 'vibeusage', openclawHome
     `    const env = {\n` +
     `      ...process.env,\n` +
     `      VIBEUSAGE_OPENCLAW_AGENT_ID: agentId,\n` +
+    `      VIBEUSAGE_OPENCLAW_SESSION_KEY: sessionKey,\n` +
     `      VIBEUSAGE_OPENCLAW_PREV_SESSION_ID: sessionId,\n` +
     `      VIBEUSAGE_OPENCLAW_HOME: openclawHome\n` +
     `    };\n` +
+    `    const prevTotalTokens = toNonNegativeInt(sessionEntry && sessionEntry.totalTokens);\n` +
+    `    const prevInputTokens = toNonNegativeInt(sessionEntry && sessionEntry.inputTokens);\n` +
+    `    const prevOutputTokens = toNonNegativeInt(sessionEntry && sessionEntry.outputTokens);\n` +
+    `    const prevModel = normalize(sessionEntry && sessionEntry.model);\n` +
+    `    const prevUpdatedAt = toIso(sessionEntry && sessionEntry.updatedAt);\n` +
+    `    if (prevTotalTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_TOTAL_TOKENS = String(prevTotalTokens);\n` +
+    `    if (prevInputTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_INPUT_TOKENS = String(prevInputTokens);\n` +
+    `    if (prevOutputTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_OUTPUT_TOKENS = String(prevOutputTokens);\n` +
+    `    if (prevModel) env.VIBEUSAGE_OPENCLAW_PREV_MODEL = prevModel;\n` +
+    `    if (prevUpdatedAt) env.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT = prevUpdatedAt;\n` +
     `\n` +
     `    const hasLocalRuntime = fs.existsSync(trackerBinPath);\n` +
     `    const hasLocalDeps = fs.existsSync(depsMarkerPath);\n` +
@@ -323,6 +335,32 @@ function buildHookHandler({ trackerDir, packageName = 'vibeusage', openclawHome
     `  return s.length > 0 ? s : null;\n` +
     `}\n` +
     `\n` +
+    `function resolveSessionEntry(event) {\n` +
+    `  const ctx = (event && event.context && typeof event.context === 'object') ? event.context : {};\n` +
+    `  if (event && event.action === 'stop') return (ctx.sessionEntry && typeof ctx.sessionEntry === 'object') ? ctx.sessionEntry : null;\n` +
+    `  if (ctx.previousSessionEntry && typeof ctx.previousSessionEntry === 'object') return ctx.previousSessionEntry;\n` +
+    `  if (ctx.sessionEntry && typeof ctx.sessionEntry === 'object') return ctx.sessionEntry;\n` +
+    `  return null;\n` +
+    `}\n` +
+    `\n` +
+    `function toNonNegativeInt(v) {\n` +
+    `  const n = Number(v);\n` +
+    `  if (!Number.isFinite(n) || n < 0) return null;\n` +
+    `  return Math.floor(n);\n` +
+    `}\n` +
+    `\n` +
+    `function toIso(v) {\n` +
+    `  if (typeof v === 'string') {\n` +
+    `    const s = normalize(v);\n` +
+    `    if (s && !Number.isNaN(Date.parse(s))) return s;\n` +
+    `  }\n` +
+    `  const n = Number(v);\n` +
+    `  if (!Number.isFinite(n) || n <= 0) return null;\n` +
+    `  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);\n` +
+    `  const d = new Date(ms);\n` +
+    `  return Number.isNaN(d.getTime()) ? null : d.toISOString();\n` +
+    `}\n` +
+    `\n` +
     `function parseAgentId(sessionKey) {\n` +
     `  const s = normalize(sessionKey);\n` +
     `  if (!s || !s.startsWith('agent:')) return null;\n` +