vibeusage 0.3.4 → 0.4.0

package/src/lib/hermes-usage-ledger.js

@@ -0,0 +1,123 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const ALLOWED_HERMES_LEDGER_FIELDS = [
+  "version",
+  "type",
+  "source",
+  "session_id",
+  "platform",
+  "model",
+  "provider",
+  "api_mode",
+  "api_call_count",
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_write_tokens",
+  "reasoning_tokens",
+  "total_tokens",
+  "finish_reason",
+  "emitted_at",
+];
+
+function resolveHermesUsageLedgerPaths({ trackerDir } = {}) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return {
+    ledgerPath: path.join(trackerDir, "hermes.usage.jsonl"),
+  };
+}
+
+async function readHermesUsageLedger({ trackerDir, offset = 0 } = {}) {
+  const { ledgerPath } = resolveHermesUsageLedgerPaths({ trackerDir });
+  const buffer = await fs.readFile(ledgerPath).catch((err) => {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  });
+
+  if (!buffer) {
+    return { events: [], endOffset: 0 };
+  }
+
+  const startOffset = Math.max(0, Number(offset || 0));
+  const fileEndOffset = buffer.length;
+  if (startOffset >= fileEndOffset) {
+    return { events: [], endOffset: fileEndOffset };
+  }
+
+  const newlineIndex = buffer.lastIndexOf(0x0a);
+  if (newlineIndex < startOffset) {
+    return { events: [], endOffset: startOffset };
+  }
+
+  const endOffset = newlineIndex + 1;
+  const raw = buffer.subarray(startOffset, endOffset).toString("utf8");
+  const events = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch (_err) {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .map(stripToAllowedHermesFields)
+    .filter(isHermesLedgerEvent);
+
+  return { events, endOffset };
+}
+
+async function readLastHermesUsageEvent({ trackerDir } = {}) {
+  const { ledgerPath } = resolveHermesUsageLedgerPaths({ trackerDir });
+  const text = await fs.readFile(ledgerPath, "utf8").catch((err) => {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  });
+  if (!text) return null;
+
+  const lines = text.split(/\r?\n/);
+  for (let idx = lines.length - 1; idx >= 0; idx -= 1) {
+    const line = String(lines[idx] || "").trim();
+    if (!line) continue;
+    try {
+      const parsed = stripToAllowedHermesFields(JSON.parse(line));
+      if (isHermesLedgerEvent(parsed)) return parsed;
+    } catch (_err) {
+      // ignore malformed line
+    }
+  }
+  return null;
+}
+
+function stripToAllowedHermesFields(event) {
+  const out = {};
+  for (const field of ALLOWED_HERMES_LEDGER_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(event, field)) continue;
+    out[field] = event[field];
+  }
+  return out;
+}
+
+function isHermesLedgerEvent(event) {
+  if (!event || typeof event !== "object") return false;
+  if (normalizeString(event.source) !== "hermes") return false;
+  const type = normalizeString(event.type);
+  if (!type || !["session_start", "usage", "session_end"].includes(type)) return false;
+  return true;
+}
+
+function normalizeString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+module.exports = {
+  ALLOWED_HERMES_LEDGER_FIELDS,
+  resolveHermesUsageLedgerPaths,
+  readHermesUsageLedger,
+  readLastHermesUsageEvent,
+};

package/src/lib/integrations/context.js

@@ -7,8 +7,14 @@ const {
   resolveGeminiSettingsPath,
   buildGeminiHookCommand,
 } = require("../gemini-config");
+const {
+  resolveKimiConfigDir,
+  resolveKimiConfigPath,
+  buildKimiHookCommand,
+} = require("../kimi-config");
 const { resolveOpencodeConfigDir } = require("../opencode-config");
 const { resolveOpenclawSessionPluginPaths } = require("../openclaw-session-plugin");
+const { resolveHermesPluginPaths } = require("../hermes-config");
 const { resolveTrackerPaths } = require("../tracker-paths");
 
 async function createIntegrationContext({
@@ -24,6 +30,7 @@ async function createIntegrationContext({
   const codeHome = env.CODE_HOME || path.join(home, ".code");
   const claudeDir = path.join(home, ".claude");
   const geminiConfigDir = resolveGeminiConfigDir({ home, env });
+  const kimiConfigDir = resolveKimiConfigDir({ home, env });
   const opencodeConfigDir = resolveOpencodeConfigDir({ home, env });
 
   return {
@@ -54,9 +61,20 @@ async function createIntegrationContext({
       settingsPath: resolveGeminiSettingsPath({ configDir: geminiConfigDir }),
       hookCommand: buildGeminiHookCommand(resolvedNotifyPath),
     },
+    kimi: {
+      configDir: kimiConfigDir,
+      configPath: resolveKimiConfigPath({ configDir: kimiConfigDir }),
+      hookCommand: buildKimiHookCommand(resolvedNotifyPath),
+      sessionsDir: path.join(kimiConfigDir, "sessions"),
+    },
     opencode: {
       configDir: opencodeConfigDir,
     },
+    hermes: resolveHermesPluginPaths({
+      home,
+      env,
+      trackerDir: resolvedTrackerPaths.trackerDir,
+    }),
     openclawSession: resolveOpenclawSessionPluginPaths({
       home,
       trackerDir: resolvedTrackerPaths.trackerDir,

package/src/lib/integrations/hermes.js

@@ -0,0 +1,96 @@
+const { isDir } = require("./utils");
+const { probeHermesPlugin, installHermesPlugin, removeHermesPlugin } = require("../hermes-config");
+
+module.exports = {
+  name: "hermes",
+  summaryLabel: "Hermes Plugin",
+  statusLabel: "Hermes plugin",
+  async probe(ctx) {
+    const hermesHomeExists = await isDir(ctx.hermes.hermesHome);
+    if (!hermesHomeExists) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "Hermes home not found",
+        initPreviewStatus: "skipped",
+        initPreviewDetail: "Hermes not detected",
+      });
+    }
+
+    const state = await probeHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    return baseProbe(this, state);
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.hermes.hermesHome))) {
+      return action(this, "skipped", false, "Hermes home not found");
+    }
+    const result = await installHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Plugin installed" : "Plugin already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.hermes.hermesHome))) {
+      return action(this, "skipped", false, "Hermes home not found", {
+        skippedReason: "hermes-home-missing",
+      });
+    }
+    const result = await removeHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    if (result.removed) {
+      return action(this, "removed", true, result.pluginDir || ctx.hermes.pluginDir);
+    }
+    if (result.skippedReason === "plugin-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result.skippedReason === "unexpected-content") {
+      return action(this, "skipped", false, "unexpected content", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "Hermes home not found", {
+      skippedReason: result.skippedReason || "hermes-home-missing",
+    });
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/index.js

@@ -3,7 +3,9 @@ const codex = require("./codex");
 const everyCode = require("./every-code");
 const claude = require("./claude");
 const gemini = require("./gemini");
+const kimi = require("./kimi");
 const opencode = require("./opencode");
+const hermes = require("./hermes");
 const openclawSession = require("./openclaw-session");
 
 const INTEGRATIONS = [
@@ -11,7 +13,9 @@ const INTEGRATIONS = [
   everyCode,
   claude,
   gemini,
+  kimi,
   opencode,
+  hermes,
   openclawSession,
 ];
 

package/src/lib/integrations/kimi.js

@@ -0,0 +1,105 @@
+const {
+  isKimiHookConfigured,
+  upsertKimiHook,
+  removeKimiHook,
+  probeKimiHook,
+} = require("../kimi-config");
+const { isDir, isFile } = require("./utils");
+
+module.exports = {
+  name: "kimi",
+  summaryLabel: "Kimi",
+  statusLabel: "Kimi hooks",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.kimi.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+    const hasConfigFile = await isFile(ctx.kimi.configPath);
+    if (!hasConfigFile) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "config.toml not found",
+      });
+    }
+    const state = await probeKimiHook({
+      configPath: ctx.kimi.configPath,
+      hookCommand: ctx.kimi.hookCommand,
+    });
+    if (state.configured) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Hooks installed",
+        configured: true,
+      });
+    }
+    return baseProbe(this, {
+      status: state.drifted ? "drifted" : "not_installed",
+      detail: state.drifted
+        ? "Run vibeusage init to reconcile hooks"
+        : "Run vibeusage init to install hooks",
+    });
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.kimi.configDir))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    if (!(await isFile(ctx.kimi.configPath))) {
+      return action(this, "skipped", false, "config.toml not found");
+    }
+    const result = await upsertKimiHook({
+      configPath: ctx.kimi.configPath,
+      hookCommand: ctx.kimi.hookCommand,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Hooks installed" : "Hooks already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.kimi.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeKimiHook({ configPath: ctx.kimi.configPath });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.kimi.configPath);
+    }
+    if (result.skippedReason === "hook-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "config.toml not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}
+
+// Expose for tests / diagnostics that want the probe-only check.
+module.exports.isKimiHookConfigured = isKimiHookConfigured;

package/src/lib/kimi-config.js

@@ -0,0 +1,221 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+
+const { ensureDir } = require("./fs");
+
+const DEFAULT_EVENTS = ["SessionEnd", "Stop"];
+const DEFAULT_TIMEOUT = 30;
+const MANAGED_START = "# --- vibeusage Kimi hooks START (managed, do not edit) ---";
+const MANAGED_END = "# --- vibeusage Kimi hooks END ---";
+
+function resolveKimiConfigDir({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.KIMI_HOME === "string" ? env.KIMI_HOME.trim() : "";
+  if (explicit) return path.resolve(explicit);
+  return path.join(home, ".kimi");
+}
+
+function resolveKimiConfigPath({ configDir }) {
+  return path.join(configDir, "config.toml");
+}
+
+function buildKimiHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === "string" ? notifyPath : "";
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=kimi`;
+}
+
+async function upsertKimiHook({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const existing = await readFileOrEmpty(configPath);
+  const normalizedEvents = normalizeEvents(events);
+  const nextBlock = buildManagedBlock({
+    hookCommand,
+    events: normalizedEvents,
+    timeout: normalizeTimeout(timeout),
+  });
+  const { content, changed } = replaceManagedBlock(existing, nextBlock);
+  if (!changed) return { changed: false, backupPath: null };
+  const backupPath = await writeWithBackup({ configPath, content });
+  return { changed: true, backupPath };
+}
+
+async function removeKimiHook({ configPath }) {
+  const existing = await readFileOrEmpty(configPath);
+  if (!existing) return { removed: false, skippedReason: "config-missing", backupPath: null };
+  const { content, changed } = stripManagedBlock(existing);
+  if (!changed) return { removed: false, skippedReason: "hook-missing", backupPath: null };
+  const backupPath = await writeWithBackup({ configPath, content });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isKimiHookConfigured({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const probe = await probeKimiHook({ configPath, hookCommand, events, timeout });
+  return probe.configured;
+}
+
+async function probeKimiHook({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const existing = await readFileOrEmpty(configPath);
+  if (!existing) {
+    return { configured: false, anyPresent: false, drifted: false };
+  }
+  const block = extractManagedBlock(existing);
+  if (!block) {
+    return { configured: false, anyPresent: false, drifted: false };
+  }
+  const expected = buildManagedBlock({
+    hookCommand,
+    events: normalizeEvents(events),
+    timeout: normalizeTimeout(timeout),
+  });
+  return {
+    configured: block === expected,
+    anyPresent: true,
+    drifted: block !== expected,
+  };
+}
+
+function buildManagedBlock({ hookCommand, events, timeout }) {
+  const lines = [MANAGED_START];
+  for (const event of events) {
+    lines.push(
+      "[[hooks]]",
+      `event = ${tomlString(event)}`,
+      `command = ${tomlString(hookCommand)}`,
+      `timeout = ${timeout}`,
+    );
+    lines.push("");
+  }
+  lines.push(MANAGED_END);
+  return lines.join("\n");
+}
+
+function replaceManagedBlock(existing, nextBlock) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const blockEnd = endIdx + MANAGED_END.length;
+    const current = existing.slice(startIdx, blockEnd);
+    if (current === nextBlock) return { content: existing, changed: false };
+    const before = existing.slice(0, startIdx);
+    let after = existing.slice(blockEnd);
+    if (after.startsWith("\n")) after = after.slice(1);
+    const beforeTrimmed = before.replace(/\n+$/, "");
+    const prefix = beforeTrimmed.length > 0 ? `${beforeTrimmed}\n\n` : "";
+    const suffix = after.length > 0 ? `\n\n${after.replace(/^\n+/, "")}` : "\n";
+    return { content: `${prefix}${nextBlock}${suffix}`, changed: true };
+  }
+
+  const base = existing.replace(/\n+$/, "");
+  const prefix = base.length > 0 ? `${base}\n\n` : "";
+  return { content: `${prefix}${nextBlock}\n`, changed: true };
+}
+
+function stripManagedBlock(existing) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+    return { content: existing, changed: false };
+  }
+  const blockEnd = endIdx + MANAGED_END.length;
+  const before = existing.slice(0, startIdx).replace(/\n+$/, "");
+  let after = existing.slice(blockEnd);
+  after = after.replace(/^\n+/, "");
+  if (before.length === 0 && after.length === 0) {
+    return { content: "", changed: true };
+  }
+  if (before.length === 0) return { content: `${after.endsWith("\n") ? after : `${after}\n`}`, changed: true };
+  if (after.length === 0) return { content: `${before}\n`, changed: true };
+  return { content: `${before}\n\n${after.endsWith("\n") ? after : `${after}\n`}`, changed: true };
+}
+
+function extractManagedBlock(existing) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return null;
+  const blockEnd = endIdx + MANAGED_END.length;
+  return existing.slice(startIdx, blockEnd);
+}
+
+function normalizeEvents(raw) {
+  const values = Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const normalized = value.trim();
+    if (!normalized || out.includes(normalized)) continue;
+    out.push(normalized);
+  }
+  return out.length > 0 ? out : DEFAULT_EVENTS.slice();
+}
+
+function normalizeTimeout(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_TIMEOUT;
+  return Math.floor(n);
+}
+
+function tomlString(value) {
+  const v = typeof value === "string" ? value : String(value ?? "");
+  return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function quoteArg(value) {
+  const v = typeof value === "string" ? value : "";
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function readFileOrEmpty(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return "";
+    throw err;
+  }
+}
+
+async function writeWithBackup({ configPath, content }) {
+  await ensureDir(path.dirname(configPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(configPath);
+    if (st && st.isFile()) {
+      backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+      await fs.copyFile(configPath, backupPath);
+    }
+  } catch (_e) {
+    // no existing file
+  }
+  await fs.writeFile(configPath, content, "utf8");
+  return backupPath;
+}
+
+module.exports = {
+  DEFAULT_EVENTS,
+  DEFAULT_TIMEOUT,
+  MANAGED_START,
+  MANAGED_END,
+  resolveKimiConfigDir,
+  resolveKimiConfigPath,
+  buildKimiHookCommand,
+  upsertKimiHook,
+  removeKimiHook,
+  isKimiHookConfigured,
+  probeKimiHook,
+};

package/src/lib/opencode-usage-audit.js

@@ -2,7 +2,7 @@ const fs = require("node:fs/promises");
 const os = require("node:os");
 const path = require("node:path");
 
-const { listOpencodeMessageFiles, parseOpencodeIncremental } = require("./rollout");
+const { parseOpencodeIncremental } = require("./rollout");
 
 const BUCKET_SEPARATOR = "|";
 const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -31,7 +31,6 @@ function addTotals(target, delta) {
 }
 
 async function buildLocalHourlyTotals({ storageDir, source = "opencode" }) {
-  const messageFiles = await listOpencodeMessageFiles(storageDir);
   const opencodeDbPath = path.resolve(storageDir, "..", "opencode.db");
   const queuePath = path.join(
     os.tmpdir(),
@@ -39,7 +38,7 @@ async function buildLocalHourlyTotals({ storageDir, source = "opencode" }) {
   );
   const cursors = { version: 1, files: {}, hourly: null, opencode: null, opencodeSqlite: null };
 
-  await parseOpencodeIncremental({ messageFiles, opencodeDbPath, cursors, queuePath, source });
+  await parseOpencodeIncremental({ opencodeDbPath, cursors, queuePath, source });
   await fs.rm(queuePath, { force: true }).catch(() => {});
 
   const byHour = new Map();