vibeusage 0.3.0 → 0.3.2

package/src/lib/rollout.js

@@ -4,6 +4,7 @@ const path = require("node:path");
 const readline = require("node:readline");
 
 const { ensureDir } = require("./fs");
+const { readOpencodeSqliteRows } = require("./opencode-sqlite");
 const { hashRepoRoot, resolveGitHubPublicStatus } = require("./vibeusage-public-repo");
 
 const DEFAULT_SOURCE = "codex";
@@ -398,12 +399,14 @@ async function parseGeminiIncremental({
 
 async function parseOpencodeIncremental({
   messageFiles,
+  opencodeDbPath,
   cursors,
   queuePath,
   projectQueuePath,
   onProgress,
   source,
   publicRepoResolver,
+  readSqliteRows,
 }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
@@ -419,9 +422,13 @@ async function parseOpencodeIncremental({
   const projectMetaCache = projectEnabled ? new Map() : null;
   const publicRepoCache = projectEnabled ? new Map() : null;
   const opencodeState = normalizeOpencodeState(cursors?.opencode);
+  const opencodeSqliteState = normalizeOpencodeSqliteState(cursors?.opencodeSqlite);
   const messageIndex = opencodeState.messages;
   const touchedBuckets = new Set();
   const defaultSource = normalizeSourceInput(source) || "opencode";
+  let sqliteStatus = opencodeSqliteState.lastStatus || "never_checked";
+  let sqliteCheckedAt = opencodeSqliteState.lastCheckedAt || null;
+  let sqliteErrorCode = opencodeSqliteState.lastErrorCode || null;
 
   if (!cursors.files || typeof cursors.files !== "object") {
     cursors.files = {};
@@ -522,93 +529,88 @@ async function parseOpencodeIncremental({
     }
   }
 
-  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
-  const projectBucketsQueued = projectEnabled
-    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
-    : 0;
-  hourlyState.updatedAt = new Date().toISOString();
-  cursors.hourly = hourlyState;
-  opencodeState.updatedAt = new Date().toISOString();
-  cursors.opencode = opencodeState;
-  if (projectState) {
-    projectState.updatedAt = new Date().toISOString();
-    cursors.projectHourly = projectState;
-  }
-
-  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
-}
-
-async function parseOpenclawIncremental({
-  sessionFiles,
-  cursors,
-  queuePath,
-  projectQueuePath,
-  onProgress,
-  source,
-}) {
-  await ensureDir(path.dirname(queuePath));
-  let filesProcessed = 0;
-  let eventsAggregated = 0;
-
-  const cb = typeof onProgress === "function" ? onProgress : null;
-  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
-  const totalFiles = files.length;
-  const hourlyState = normalizeHourlyState(cursors?.hourly);
-  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
-  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
-  const projectTouchedBuckets = projectEnabled ? new Set() : null;
-  const touchedBuckets = new Set();
-  const defaultSource = normalizeSourceInput(source) || "openclaw";
-
-  if (!cursors.files || typeof cursors.files !== "object") {
-    cursors.files = {};
-  }
-
-  for (let idx = 0; idx < files.length; idx++) {
-    const entry = files[idx];
-    const filePath = typeof entry === "string" ? entry : entry?.path;
-    if (!filePath) continue;
-    const fileSource =
-      typeof entry === "string"
-        ? defaultSource
-        : normalizeSourceInput(entry?.source) || defaultSource;
-    const st = await fs.stat(filePath).catch(() => null);
-    if (!st || !st.isFile()) continue;
-
-    const key = filePath;
-    const prev = cursors.files[key] || null;
-    const inode = st.ino || 0;
-    const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
-
-    const result = await parseOpenclawSessionFile({
-      filePath,
-      startOffset,
-      hourlyState,
-      touchedBuckets,
-      source: fileSource,
-      projectState,
-      projectTouchedBuckets,
+  if (typeof opencodeDbPath === "string" && opencodeDbPath.length > 0) {
+    const readRows =
+      typeof readSqliteRows === "function" ? readSqliteRows : readOpencodeSqliteRows;
+    const sqliteResult = await readRows({
+      dbPath: opencodeDbPath,
+      lastTimeCreated: opencodeSqliteState.lastTimeCreated,
+      expectedInode: opencodeSqliteState.inode,
     });
 
-    cursors.files[key] = {
-      inode,
-      offset: result.endOffset,
-      updatedAt: new Date().toISOString(),
-    };
-
-    filesProcessed += 1;
-    eventsAggregated += result.eventsAggregated;
+    sqliteStatus =
+      typeof sqliteResult?.status === "string" && sqliteResult.status.trim()
+        ? sqliteResult.status.trim()
+        : "query-failed";
+    sqliteCheckedAt =
+      typeof sqliteResult?.checkedAt === "string" && sqliteResult.checkedAt.trim()
+        ? sqliteResult.checkedAt.trim()
+        : new Date().toISOString();
+    sqliteErrorCode =
+      typeof sqliteResult?.errorCode === "string" && sqliteResult.errorCode.trim()
+        ? sqliteResult.errorCode.trim()
+        : typeof sqliteResult?.error?.code === "string" && sqliteResult.error.code.trim()
+          ? sqliteResult.error.code.trim()
+          : null;
+
+    opencodeSqliteState.lastStatus = sqliteStatus;
+    opencodeSqliteState.lastCheckedAt = sqliteCheckedAt;
+    opencodeSqliteState.lastErrorCode = sqliteErrorCode;
+    opencodeSqliteState.updatedAt = new Date().toISOString();
+
+    if (sqliteStatus === "ok") {
+      const sameDb =
+        !sqliteResult.cursorReset &&
+        opencodeSqliteState.inode &&
+        sqliteResult.inode &&
+        opencodeSqliteState.inode === sqliteResult.inode;
+      const prevProcessedIds = new Set(sameDb ? opencodeSqliteState.lastProcessedIds : []);
+      const rawRows = Array.isArray(sqliteResult.rows) ? sqliteResult.rows : [];
+      const rows = prevProcessedIds.size
+        ? rawRows.filter((row) => !prevProcessedIds.has(row?.id))
+        : rawRows;
+      const knownMessageKeys = new Set([
+        ...Object.keys(messageIndex || {}),
+        ...Object.values(cursors.files || {})
+          .map((entry) => entry?.messageKey)
+          .filter((entry) => typeof entry === "string" && entry.trim()),
+      ]);
+
+      for (const row of rows) {
+        const result = await parseOpencodeSqliteRow({
+          row,
+          messageIndex,
+          knownMessageKeys,
+          hourlyState,
+          touchedBuckets,
+          source: defaultSource,
+          projectState,
+          projectTouchedBuckets,
+          projectMetaCache,
+          publicRepoCache,
+          publicRepoResolver,
+        });
+        eventsAggregated += result.eventsAggregated;
+      }
 
-    if (cb) {
-      cb({
-        index: idx + 1,
-        total: totalFiles,
-        filePath,
-        filesProcessed,
-        eventsAggregated,
-        bucketsQueued: touchedBuckets.size,
-      });
+      const lastTimeCreated = sameDb ? opencodeSqliteState.lastTimeCreated : 0;
+      const maxTime =
+        rawRows.length > 0
+          ? Math.max(
+              lastTimeCreated,
+              ...rawRows.map((row) =>
+                Number.isFinite(Number(row?.time_created)) ? Number(row.time_created) : 0,
+              ),
+            )
+          : lastTimeCreated;
+      opencodeSqliteState.lastTimeCreated = maxTime;
+      opencodeSqliteState.lastProcessedIds = rawRows
+        .filter((row) => Number(row?.time_created) === maxTime)
+        .map((row) => row?.id)
+        .filter((value) => typeof value === "string" && value.trim());
+      opencodeSqliteState.inode = sqliteResult.inode || opencodeSqliteState.inode || 0;
     }
+    cursors.opencodeSqlite = opencodeSqliteState;
   }
 
   const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
@@ -617,80 +619,22 @@ async function parseOpenclawIncremental({
     : 0;
   hourlyState.updatedAt = new Date().toISOString();
   cursors.hourly = hourlyState;
+  opencodeState.updatedAt = new Date().toISOString();
+  cursors.opencode = opencodeState;
   if (projectState) {
     projectState.updatedAt = new Date().toISOString();
     cursors.projectHourly = projectState;
   }
 
-  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
-}
-
-async function parseOpenclawSessionFile({
-  filePath,
-  startOffset,
-  hourlyState,
-  touchedBuckets,
-  source,
-  projectState,
-  projectTouchedBuckets,
-}) {
-  const st = await fs.stat(filePath);
-  const endOffset = st.size;
-  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
-
-  const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-  let eventsAggregated = 0;
-  for await (const line of rl) {
-    if (!line) continue;
-    // Fast-path filter: OpenClaw assistant messages include message.usage.totalTokens.
-    if (!line.includes('"usage"') || !line.includes("totalTokens")) continue;
-
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch (_e) {
-      continue;
-    }
-
-    if (obj?.type !== "message") continue;
-    const msg = obj?.message;
-    if (!msg || typeof msg !== "object") continue;
-
-    const usage = msg.usage;
-    if (!usage || typeof usage !== "object") continue;
-
-    const tokenTimestamp = typeof obj?.timestamp === "string" ? obj.timestamp : null;
-    if (!tokenTimestamp) continue;
-
-    const model = normalizeModelInput(msg.model) || DEFAULT_MODEL;
-
-    const delta = {
-      input_tokens: Number(usage.input || 0),
-      cached_input_tokens: Number((usage.cacheRead || 0) + (usage.cacheWrite || 0)),
-      output_tokens: Number(usage.output || 0),
-      reasoning_output_tokens: 0,
-      total_tokens: Number(usage.totalTokens || 0),
-    };
-
-    if (isAllZeroUsage(delta)) continue;
-
-    const bucketStart = toUtcHalfHourStart(tokenTimestamp);
-    if (!bucketStart) continue;
-
-    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
-    addTotals(bucket.totals, delta);
-    touchedBuckets.add(bucketKey(source, model, bucketStart));
-
-    // Project-level OpenClaw attribution is not supported yet (no stable cwd info).
-    // If OpenClaw later records cwd per event, we can mirror rollout's project logic.
-    eventsAggregated += 1;
-  }
-
-  rl.close();
-  stream.close?.();
-  return { endOffset, eventsAggregated };
+  return {
+    filesProcessed,
+    eventsAggregated,
+    bucketsQueued,
+    projectBucketsQueued,
+    sqliteStatus,
+    sqliteCheckedAt,
+    sqliteErrorCode,
+  };
 }
 
 async function parseRolloutFile({
@@ -1062,6 +1006,107 @@ async function parseOpencodeMessageFile({
   return { messageKey, lastTotals: currentTotals, eventsAggregated: 1, shouldUpdate: true };
 }
 
+async function parseOpencodeSqliteRow({
+  row,
+  messageIndex,
+  knownMessageKeys,
+  hourlyState,
+  touchedBuckets,
+  source,
+  projectState,
+  projectTouchedBuckets,
+  projectMetaCache,
+  publicRepoCache,
+  publicRepoResolver,
+}) {
+  if (!row || typeof row !== "object") {
+    return { eventsAggregated: 0 };
+  }
+
+  let msg;
+  try {
+    msg = JSON.parse(String(row.data || ""));
+  } catch (_e) {
+    return { eventsAggregated: 0 };
+  }
+
+  const rowRole =
+    normalizeMessageKeyPart(row.role) ||
+    normalizeMessageKeyPart(msg?.role) ||
+    normalizeMessageKeyPart(msg?.type);
+  if (rowRole && rowRole !== "assistant") {
+    return { eventsAggregated: 0 };
+  }
+
+  const messageKey = deriveOpencodeMessageKey(msg, null);
+  if (!messageKey || knownMessageKeys.has(messageKey)) {
+    return { eventsAggregated: 0 };
+  }
+
+  const currentTotals = normalizeOpencodeTokens(msg?.tokens);
+  if (!currentTotals || isAllZeroUsage(currentTotals)) {
+    return { eventsAggregated: 0 };
+  }
+
+  const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+  if (!timestampMs) {
+    return { eventsAggregated: 0 };
+  }
+
+  const bucketStart = toUtcHalfHourStart(new Date(timestampMs).toISOString());
+  if (!bucketStart) {
+    return { eventsAggregated: 0 };
+  }
+
+  const model = normalizeModelInput(msg?.modelID || msg?.model || msg?.modelId) || DEFAULT_MODEL;
+  const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+  addTotals(bucket.totals, currentTotals);
+  touchedBuckets.add(bucketKey(source, model, bucketStart));
+
+  const projectWorktree =
+    typeof row.project_worktree === "string" && row.project_worktree.trim()
+      ? row.project_worktree.trim()
+      : null;
+  if (
+    projectWorktree &&
+    projectState &&
+    projectTouchedBuckets &&
+    projectMetaCache &&
+    publicRepoCache
+  ) {
+    const projectContext = await resolveProjectContextForPath({
+      startDir: projectWorktree,
+      projectMetaCache,
+      publicRepoCache,
+      publicRepoResolver,
+      projectState,
+    });
+    const projectRef = projectContext?.projectRef || null;
+    const projectKey = projectContext?.projectKey || null;
+    if (projectKey) {
+      const projectBucket = getProjectBucket(
+        projectState,
+        projectKey,
+        source,
+        bucketStart,
+        projectRef,
+      );
+      addTotals(projectBucket.totals, currentTotals);
+      projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+    }
+  }
+
+  if (messageIndex && typeof messageIndex === "object") {
+    messageIndex[messageKey] = {
+      lastTotals: currentTotals,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+  knownMessageKeys.add(messageKey);
+
+  return { eventsAggregated: 1 };
+}
+
 async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets }) {
   if (!touchedBuckets || touchedBuckets.size === 0) return 0;
 
@@ -1559,6 +1604,32 @@ function normalizeOpencodeState(raw) {
   };
 }
 
+function normalizeOpencodeSqliteState(raw) {
+  const state = raw && typeof raw === "object" ? raw : {};
+  return {
+    lastTimeCreated: Number.isFinite(Number(state.lastTimeCreated))
+      ? Number(state.lastTimeCreated)
+      : 0,
+    lastProcessedIds: Array.isArray(state.lastProcessedIds)
+      ? state.lastProcessedIds
+          .filter((value) => typeof value === "string" && value.trim())
+          .map((value) => value.trim())
+      : [],
+    inode: Number.isFinite(Number(state.inode)) ? Number(state.inode) : 0,
+    updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : null,
+    lastStatus:
+      typeof state.lastStatus === "string" && state.lastStatus.trim() ? state.lastStatus.trim() : null,
+    lastCheckedAt:
+      typeof state.lastCheckedAt === "string" && state.lastCheckedAt.trim()
+        ? state.lastCheckedAt.trim()
+        : null,
+    lastErrorCode:
+      typeof state.lastErrorCode === "string" && state.lastErrorCode.trim()
+        ? state.lastErrorCode.trim()
+        : null,
+  };
+}
+
 function normalizeMessageKeyPart(value) {
   if (typeof value !== "string") return "";
   return value.trim();
@@ -2227,5 +2298,10 @@ module.exports = {
   parseClaudeIncremental,
   parseGeminiIncremental,
   parseOpencodeIncremental,
-  parseOpenclawIncremental,
+  normalizeHourlyState,
+  getHourlyBucket,
+  addTotals,
+  bucketKey,
+  enqueueTouchedBuckets,
+  toUtcHalfHourStart,
 };

package/src/lib/vibeusage-api.js

@@ -7,7 +7,7 @@ const {
 } = require("../shared/vibeusage-function-contract.cjs");
 
 async function signInWithPassword({ baseUrl, email, password }) {
-  const client = createInsforgeClient({ baseUrl });
+  const client = await createInsforgeClient({ baseUrl });
   const { data, error } = await client.auth.signInWithPassword({ email, password });
   if (error) throw normalizeSdkError(error, "Sign-in failed");
 
@@ -121,7 +121,7 @@ module.exports = {
 };
 
 async function invokeFunction({ baseUrl, accessToken, slug, method, body, errorPrefix }) {
-  const client = createInsforgeClient({ baseUrl, accessToken });
+  const client = await createInsforgeClient({ baseUrl, accessToken });
   const { data, error } = await client.functions.invoke(slug, { method, body });
   if (error) throw normalizeSdkError(error, errorPrefix);
   return data;

package/src/lib/integrations/openclaw-legacy.js

@@ -1,123 +0,0 @@
-const { probeOpenclawHookState, removeOpenclawHookConfig } = require("../openclaw-hook");
-
-module.exports = {
-  name: "openclaw-legacy",
-  summaryLabel: "OpenClaw Hook (legacy)",
-  statusLabel: "OpenClaw hook (legacy)",
-  async probe(ctx) {
-    const state = await probeOpenclawHookState({
-      home: ctx.home,
-      trackerDir: ctx.trackerPaths.trackerDir,
-      env: ctx.env,
-    });
-    if (state?.skippedReason === "openclaw-config-missing") {
-      return baseProbe(this, { status: "not_installed", detail: "OpenClaw config not found" });
-    }
-    if (state?.skippedReason === "openclaw-config-unreadable") {
-      return baseProbe(this, {
-        status: "unreadable",
-        detail: state.error
-          ? `OpenClaw config unreadable: ${state.error}`
-          : "OpenClaw config unreadable",
-        linked: Boolean(state.linked),
-        enabled: Boolean(state.enabled),
-      });
-    }
-    if (state?.configured || state?.linked || state?.enabled) {
-      return baseProbe(this, {
-        status: "unsupported_legacy",
-        detail: "Legacy OpenClaw hook detected; run vibeusage init",
-        linked: Boolean(state.linked),
-        enabled: Boolean(state.enabled),
-      });
-    }
-    return baseProbe(this, { status: "not_installed", detail: "Legacy hook not installed" });
-  },
-  async install(ctx) {
-    const state = await probeOpenclawHookState({
-      home: ctx.home,
-      trackerDir: ctx.trackerPaths.trackerDir,
-      env: ctx.env,
-    });
-    if (state?.skippedReason === "openclaw-config-unreadable") {
-      return action(
-        this,
-        "skipped",
-        false,
-        state.error ? `OpenClaw config unreadable: ${state.error}` : "OpenClaw config unreadable",
-        { skippedReason: state.skippedReason },
-      );
-    }
-    if (!(state?.configured || state?.linked || state?.enabled)) {
-      return action(this, "unchanged", false, "no change");
-    }
-    const result = await removeOpenclawHookConfig({
-      home: ctx.home,
-      trackerDir: ctx.trackerPaths.trackerDir,
-      env: ctx.env,
-    });
-    if (result?.removed) {
-      return action(this, "updated", true, "Removed legacy command hook");
-    }
-    if (result?.skippedReason === "openclaw-config-unreadable") {
-      return action(
-        this,
-        "skipped",
-        false,
-        result.error ? `OpenClaw config unreadable: ${result.error}` : "OpenClaw config unreadable",
-        { skippedReason: result.skippedReason },
-      );
-    }
-    return action(this, "unchanged", false, "no change");
-  },
-  async uninstall(ctx) {
-    const result = await removeOpenclawHookConfig({
-      home: ctx.home,
-      trackerDir: ctx.trackerPaths.trackerDir,
-      env: ctx.env,
-    });
-    if (result?.removed) {
-      return action(this, "removed", true, result.openclawConfigPath);
-    }
-    if (result?.skippedReason === "openclaw-config-missing") {
-      return action(this, "skipped", false, "openclaw config not found", {
-        skippedReason: result.skippedReason,
-      });
-    }
-    if (result?.skippedReason === "openclaw-config-unreadable") {
-      return action(
-        this,
-        "skipped",
-        false,
-        result.error ? `openclaw config unreadable: ${result.error}` : "openclaw config unreadable",
-        { skippedReason: result.skippedReason },
-      );
-    }
-    return action(this, "unchanged", false, "no change");
-  },
-  renderStatusValue(probe) {
-    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,
-  };
-}