vibeusage 0.2.23 → 0.3.1

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,6 +529,90 @@ async function parseOpencodeIncremental({
     }
   }
 
+  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,
+    });
+
+    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;
+      }
+
+      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 });
   const projectBucketsQueued = projectEnabled
     ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
@@ -535,7 +626,15 @@ async function parseOpencodeIncremental({
     cursors.projectHourly = projectState;
   }
 
-  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+  return {
+    filesProcessed,
+    eventsAggregated,
+    bucketsQueued,
+    projectBucketsQueued,
+    sqliteStatus,
+    sqliteCheckedAt,
+    sqliteErrorCode,
+  };
 }
 
 async function parseOpenclawIncremental({
@@ -1062,6 +1161,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 +1759,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();

package/src/lib/runtime-config.js

@@ -1,6 +1,8 @@
-const DEFAULT_BASE_URL = "https://5tmappuk.us-east.insforge.app";
-const DEFAULT_DASHBOARD_URL = "https://www.vibeusage.cc";
-const DEFAULT_HTTP_TIMEOUT_MS = 20_000;
+const {
+  DEFAULT_INSFORGE_BASE_URL,
+  DEFAULT_DASHBOARD_URL,
+  DEFAULT_HTTP_TIMEOUT_MS,
+} = require("../shared/runtime-defaults.cjs");
 
 function resolveRuntimeConfig({ cli = {}, config = {}, env = process.env, defaults = {} } = {}) {
   const baseUrl = pickString(
@@ -8,7 +10,7 @@ function resolveRuntimeConfig({ cli = {}, config = {}, env = process.env, defaul
     config.baseUrl,
     env?.VIBEUSAGE_INSFORGE_BASE_URL,
     defaults.baseUrl,
-    DEFAULT_BASE_URL,
+    DEFAULT_INSFORGE_BASE_URL,
   );
   const dashboardUrl = pickString(
     cli.dashboardUrl,
@@ -125,7 +127,7 @@ function clampInt(value, min, max) {
 }
 
 module.exports = {
-  DEFAULT_BASE_URL,
+  DEFAULT_BASE_URL: DEFAULT_INSFORGE_BASE_URL,
   DEFAULT_DASHBOARD_URL,
   DEFAULT_HTTP_TIMEOUT_MS,
   resolveRuntimeConfig,

package/src/lib/vibeusage-api.js

@@ -1,9 +1,13 @@
 "use strict";
 
 const { createInsforgeClient } = require("./insforge-client");
+const {
+  BACKEND_RUNTIME_UNAVAILABLE_MESSAGE,
+  FUNCTION_SLUGS,
+} = 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");
 
@@ -19,7 +23,7 @@ async function issueDeviceToken({ baseUrl, accessToken, deviceName, platform = "
   const data = await invokeFunction({
     baseUrl,
     accessToken,
-    slug: "vibeusage-device-token-issue",
+    slug: FUNCTION_SLUGS.deviceTokenIssue,
     method: "POST",
     body: { device_name: deviceName, platform },
     errorPrefix: "Device token issue failed",
@@ -40,7 +44,7 @@ async function exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, plat
   const data = await invokeFunction({
     baseUrl,
     accessToken: null,
-    slug: "vibeusage-link-code-exchange",
+    slug: FUNCTION_SLUGS.linkCodeExchange,
     method: "POST",
     body: {
       link_code: linkCode,
@@ -78,7 +82,7 @@ async function ingestHourly({
   const data = await invokeFunctionWithRetry({
     baseUrl,
     accessToken: deviceToken,
-    slug: "vibeusage-ingest",
+    slug: FUNCTION_SLUGS.ingest,
     method: "POST",
     body,
     errorPrefix: "Ingest failed",
@@ -95,7 +99,7 @@ async function syncHeartbeat({ baseUrl, deviceToken }) {
   const data = await invokeFunction({
     baseUrl,
     accessToken: deviceToken,
-    slug: "vibeusage-sync-ping",
+    slug: FUNCTION_SLUGS.syncPing,
     method: "POST",
     body: {},
     errorPrefix: "Sync heartbeat failed",
@@ -117,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;
@@ -174,7 +178,7 @@ function extractSdkErrorMessage(error) {
 
 function normalizeBackendErrorMessage(message) {
   if (!isBackendRuntimeDownMessage(message)) return String(message || "Unknown error");
-  return "Backend runtime unavailable (InsForge). Please retry later.";
+  return BACKEND_RUNTIME_UNAVAILABLE_MESSAGE;
 }
 
 function isBackendRuntimeDownMessage(message) {

package/src/shared/copy-registry.cjs

@@ -0,0 +1,142 @@
+"use strict";
+
+const REQUIRED_COPY_COLUMNS = ["key", "module", "page", "component", "slot", "text"];
+
+function parseCsvRows(raw) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let inQuotes = false;
+
+  for (let i = 0; i < String(raw || "").length; i += 1) {
+    const ch = raw[i];
+
+    if (inQuotes) {
+      if (ch === '"') {
+        const next = raw[i + 1];
+        if (next === '"') {
+          field += '"';
+          i += 1;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+
+    if (ch === '"') {
+      inQuotes = true;
+      continue;
+    }
+
+    if (ch === ",") {
+      row.push(field);
+      field = "";
+      continue;
+    }
+
+    if (ch === "\n") {
+      row.push(field);
+      field = "";
+      if (!row.every((cell) => String(cell).trim() === "")) {
+        rows.push(row);
+      }
+      row = [];
+      continue;
+    }
+
+    if (ch === "\r") continue;
+
+    field += ch;
+  }
+
+  row.push(field);
+  if (!row.every((cell) => String(cell).trim() === "")) {
+    rows.push(row);
+  }
+
+  return rows;
+}
+
+function buildCopyRegistry(raw) {
+  const rows = parseCsvRows(raw || "");
+  if (!rows.length) {
+    return {
+      header: [],
+      rows: [],
+      map: new Map(),
+      duplicates: new Map(),
+      missingColumns: [...REQUIRED_COPY_COLUMNS],
+    };
+  }
+
+  const header = rows[0].map((cell) => String(cell).trim());
+  const missingColumns = REQUIRED_COPY_COLUMNS.filter((col) => !header.includes(col));
+  if (missingColumns.length > 0) {
+    return {
+      header,
+      rows: [],
+      map: new Map(),
+      duplicates: new Map(),
+      missingColumns,
+    };
+  }
+
+  const indexByColumn = Object.fromEntries(header.map((col, index) => [col, index]));
+  const entries = [];
+  const map = new Map();
+  const duplicates = new Map();
+
+  rows.slice(1).forEach((cells, rowIndex) => {
+    const record = {
+      key: String(cells[indexByColumn.key] || "").trim(),
+      module: String(cells[indexByColumn.module] || "").trim(),
+      page: String(cells[indexByColumn.page] || "").trim(),
+      component: String(cells[indexByColumn.component] || "").trim(),
+      slot: String(cells[indexByColumn.slot] || "").trim(),
+      text: String(cells[indexByColumn.text] ?? "").trim(),
+      row: rowIndex + 2,
+    };
+
+    if (!record.key) return;
+
+    if (map.has(record.key)) {
+      const existingRows = duplicates.get(record.key) || [map.get(record.key).row];
+      existingRows.push(record.row);
+      duplicates.set(record.key, existingRows);
+    }
+
+    map.set(record.key, record);
+    entries.push(record);
+  });
+
+  return {
+    header,
+    rows: entries,
+    map,
+    duplicates,
+    missingColumns: [],
+  };
+}
+
+function normalizeCopyText(text) {
+  return String(text ?? "").replace(/\\n/g, "\n");
+}
+
+function interpolateCopyText(text, params) {
+  if (!params || typeof params !== "object") return text;
+  return String(text).replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    if (params[key] == null) return match;
+    return String(params[key]);
+  });
+}
+
+module.exports = {
+  REQUIRED_COPY_COLUMNS,
+  parseCsvRows,
+  buildCopyRegistry,
+  normalizeCopyText,
+  interpolateCopyText,
+};

package/src/shared/copy-registry.cjs.d.ts

@@ -0,0 +1,33 @@
+export const REQUIRED_COPY_COLUMNS: string[];
+
+export function parseCsvRows(raw: string): string[][];
+
+export function buildCopyRegistry(raw: string): {
+  header: string[];
+  rows: Array<{
+    key: string;
+    module: string;
+    page: string;
+    component: string;
+    slot: string;
+    text: string;
+    row: number;
+  }>;
+  map: Map<
+    string,
+    {
+      key: string;
+      module: string;
+      page: string;
+      component: string;
+      slot: string;
+      text: string;
+      row: number;
+    }
+  >;
+  duplicates: Map<string, number[]>;
+  missingColumns: string[];
+};
+
+export function normalizeCopyText(text: unknown): string;
+export function interpolateCopyText(text: string, params?: Record<string, unknown>): string;

package/src/shared/runtime-defaults.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+const DEFAULT_INSFORGE_BASE_URL = "https://5tmappuk.us-east.insforge.app";
+const DEFAULT_DASHBOARD_URL = "https://www.vibeusage.cc";
+const DEFAULT_HTTP_TIMEOUT_MS = 20_000;
+
+module.exports = {
+  DEFAULT_INSFORGE_BASE_URL,
+  DEFAULT_DASHBOARD_URL,
+  DEFAULT_HTTP_TIMEOUT_MS,
+};

package/src/shared/runtime-defaults.cjs.d.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_INSFORGE_BASE_URL: string;
+export const DEFAULT_DASHBOARD_URL: string;
+export const DEFAULT_HTTP_TIMEOUT_MS: number;

package/src/shared/vibeusage-function-contract.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+const FUNCTION_PREFIX = "/functions";
+const LEGACY_FUNCTION_PREFIX = "/api/functions";
+const BACKEND_RUNTIME_UNAVAILABLE_MESSAGE =
+  "Backend runtime unavailable (InsForge). Please retry later.";
+
+const FUNCTION_SLUGS = Object.freeze({
+  deviceTokenIssue: "vibeusage-device-token-issue",
+  ingest: "vibeusage-ingest",
+  syncPing: "vibeusage-sync-ping",
+  usageSummary: "vibeusage-usage-summary",
+  usageDaily: "vibeusage-usage-daily",
+  usageHourly: "vibeusage-usage-hourly",
+  usageMonthly: "vibeusage-usage-monthly",
+  usageHeatmap: "vibeusage-usage-heatmap",
+  usageModelBreakdown: "vibeusage-usage-model-breakdown",
+  projectUsageSummary: "vibeusage-project-usage-summary",
+  leaderboard: "vibeusage-leaderboard",
+  leaderboardProfile: "vibeusage-leaderboard-profile",
+  userStatus: "vibeusage-user-status",
+  viewerIdentity: "vibeusage-viewer-identity",
+  linkCodeInit: "vibeusage-link-code-init",
+  linkCodeExchange: "vibeusage-link-code-exchange",
+  publicViewProfile: "vibeusage-public-view-profile",
+  publicVisibility: "vibeusage-public-visibility",
+});
+
+module.exports = {
+  FUNCTION_PREFIX,
+  LEGACY_FUNCTION_PREFIX,
+  BACKEND_RUNTIME_UNAVAILABLE_MESSAGE,
+  FUNCTION_SLUGS,
+};

package/src/shared/vibeusage-function-contract.cjs.d.ts

@@ -0,0 +1,4 @@
+export const FUNCTION_PREFIX: string;
+export const LEGACY_FUNCTION_PREFIX: string;
+export const BACKEND_RUNTIME_UNAVAILABLE_MESSAGE: string;
+export const FUNCTION_SLUGS: Record<string, string>;

package/src/commands/activate-if-needed.js

@@ -1,41 +0,0 @@
-const { checkAndActivate } = require("../lib/activation-check");
-
-/**
- * 检测并激活未配置的 AI CLI 集成
- * 用于 hooks 或其他触发器调用
- */
-async function cmdActivateIfNeeded(argv) {
-  const opts = parseArgs(argv);
-  
-  const results = await checkAndActivate({
-    silent: opts.silent,
-    autoConfigure: true,
-  });
-  
-  if (!opts.silent) {
-    if (results.length === 0) {
-      console.log("所有 AI CLI 集成已配置完成");
-    } else {
-      for (const r of results) {
-        const icon = r.action === "configured" ? "✅" : "❌";
-        console.log(`${icon} ${r.displayName}: ${r.action}`);
-      }
-    }
-  }
-  
-  // 如果有任何配置成功，返回 0，否则返回 1
-  const hasSuccess = results.some(r => r.action === "configured");
-  process.exitCode = hasSuccess ? 0 : 0; // 始终返回 0，不阻塞调用方
-}
-
-function parseArgs(argv) {
-  const out = {
-    silent: false,
-  };
-  for (const a of argv) {
-    if (a === "--silent") out.silent = true;
-  }
-  return out;
-}
-
-module.exports = { cmdActivateIfNeeded };