@vibescore/tracker 0.0.2 → 0.0.3

package/bin/tracker.js

@@ -9,10 +9,19 @@ if (debug) process.env.VIBESCORE_DEBUG = '1';
 run(argv).catch((err) => {
   console.error(err?.stack || String(err));
   if (debug) {
+    if (typeof err?.status === 'number') {
+      console.error(`Status: ${err.status}`);
+    }
+    if (typeof err?.code === 'string' && err.code.trim()) {
+      console.error(`Code: ${err.code.trim()}`);
+    }
     const original = err?.originalMessage;
     if (original && original !== err?.message) {
       console.error(`Original error: ${original}`);
     }
+    if (typeof err?.nextActions === 'string' && err.nextActions.trim()) {
+      console.error(`Next actions: ${err.nextActions.trim()}`);
+    }
   }
   process.exitCode = 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/commands/sync.js

@@ -6,6 +6,7 @@ const { ensureDir, readJson, writeJson, openLock } = require('../lib/fs');
 const { listRolloutFiles, parseRolloutIncremental } = require('../lib/rollout');
 const { drainQueueToCloud } = require('../lib/uploader');
 const { createProgress, renderBar, formatNumber, formatBytes } = require('../lib/progress');
+const { syncHeartbeat } = require('../lib/vibescore-api');
 const {
   DEFAULTS: UPLOAD_DEFAULTS,
   normalizeState: normalizeUploadState,
@@ -130,11 +131,19 @@ async function cmdSync(argv) {
       progress?.stop();
     }
 
-    if (!opts.auto) {
-      const afterState = (await readJson(queueStatePath)) || { offset: 0 };
-      const queueSize = await safeStatSize(queuePath);
-      const pendingBytes = Math.max(0, queueSize - Number(afterState.offset || 0));
+    const afterState = (await readJson(queueStatePath)) || { offset: 0 };
+    const queueSize = await safeStatSize(queuePath);
+    const pendingBytes = Math.max(0, queueSize - Number(afterState.offset || 0));
+
+    await maybeSendHeartbeat({
+      baseUrl,
+      deviceToken,
+      trackerDir,
+      uploadResult,
+      pendingBytes
+    });
 
+    if (!opts.auto) {
       process.stdout.write(
         [
           'Sync finished:',
@@ -185,3 +194,28 @@ async function safeStatSize(p) {
     return 0;
   }
 }
+
+async function maybeSendHeartbeat({ baseUrl, deviceToken, trackerDir, uploadResult, pendingBytes }) {
+  if (!deviceToken || !uploadResult) return;
+  if (pendingBytes > 0) return;
+  if (Number(uploadResult.inserted || 0) !== 0) return;
+
+  const heartbeatPath = path.join(trackerDir, 'sync.heartbeat.json');
+  const heartbeatState = await readJson(heartbeatPath);
+  const lastPingAt = Date.parse(heartbeatState?.lastPingAt || '');
+  const nowMs = Date.now();
+  if (Number.isFinite(lastPingAt) && nowMs - lastPingAt < HEARTBEAT_MIN_INTERVAL_MS) return;
+
+  try {
+    await syncHeartbeat({ baseUrl, deviceToken });
+    await writeJson(heartbeatPath, {
+      lastPingAt: new Date(nowMs).toISOString(),
+      minIntervalMinutes: HEARTBEAT_MIN_INTERVAL_MINUTES
+    });
+  } catch (_e) {
+    // best-effort heartbeat; ignore failures
+  }
+}
+
+const HEARTBEAT_MIN_INTERVAL_MINUTES = 30;
+const HEARTBEAT_MIN_INTERVAL_MS = HEARTBEAT_MIN_INTERVAL_MINUTES * 60 * 1000;

package/src/lib/vibescore-api.js

@@ -52,10 +52,28 @@ async function ingestEvents({ baseUrl, deviceToken, events }) {
   };
 }
 
+async function syncHeartbeat({ baseUrl, deviceToken }) {
+  const data = await invokeFunction({
+    baseUrl,
+    accessToken: deviceToken,
+    slug: 'vibescore-sync-ping',
+    method: 'POST',
+    body: {},
+    errorPrefix: 'Sync heartbeat failed'
+  });
+
+  return {
+    updated: Boolean(data?.updated),
+    last_sync_at: typeof data?.last_sync_at === 'string' ? data.last_sync_at : null,
+    min_interval_minutes: Number(data?.min_interval_minutes || 0)
+  };
+}
+
 module.exports = {
   signInWithPassword,
   issueDeviceToken,
-  ingestEvents
+  ingestEvents,
+  syncHeartbeat
 };
 
 async function invokeFunction({ baseUrl, accessToken, slug, method, body, errorPrefix }) {
@@ -82,17 +100,30 @@ async function invokeFunctionWithRetry({ baseUrl, accessToken, slug, method, bod
 }
 
 function normalizeSdkError(error, errorPrefix) {
-  const raw = error?.message || String(error || 'Unknown error');
+  const raw = extractSdkErrorMessage(error);
   const msg = normalizeBackendErrorMessage(raw);
   const err = new Error(errorPrefix ? `${errorPrefix}: ${msg}` : msg);
   const status = error?.statusCode ?? error?.status;
+  const code = typeof error?.error === 'string' ? error.error.trim() : '';
   if (typeof status === 'number') err.status = status;
+  if (code) err.code = code;
   err.retryable = isRetryableStatus(status) || isRetryableMessage(raw);
   if (msg !== raw) err.originalMessage = raw;
   if (error?.nextActions) err.nextActions = error.nextActions;
   return err;
 }
 
+function extractSdkErrorMessage(error) {
+  if (!error) return 'Unknown error';
+  const message = typeof error.message === 'string' ? error.message.trim() : '';
+  const code = typeof error.error === 'string' ? error.error.trim() : '';
+  if (message && message !== 'InsForgeError') return message;
+  if (code && code !== 'REQUEST_FAILED') return code;
+  if (message) return message;
+  if (code) return code;
+  return String(error);
+}
+
 function normalizeBackendErrorMessage(message) {
   if (!isBackendRuntimeDownMessage(message)) return String(message || 'Unknown error');
   return 'Backend runtime unavailable (InsForge). Please retry later.';