vibeusage 0.2.21 → 0.2.22

package/src/lib/doctor.js

@@ -1,14 +1,14 @@
-const fs = require('node:fs/promises');
-const { constants } = require('node:fs');
+const fs = require("node:fs/promises");
+const { constants } = require("node:fs");
 
-const { readJsonStrict } = require('./fs');
+const { readJsonStrict } = require("./fs");
 
 async function buildDoctorReport({
   runtime = {},
   diagnostics = null,
   fetch = globalThis.fetch,
   now = () => new Date(),
-  paths = {}
+  paths = {},
 } = {}) {
   const checks = [];
 
@@ -38,96 +38,103 @@ async function buildDoctorReport({
     ok: summary.critical === 0,
     summary,
     checks,
-    diagnostics
+    diagnostics,
   };
 }
 
 function buildRuntimeChecks(runtime = {}) {
   const checks = [];
-  const baseUrl = typeof runtime.baseUrl === 'string' && runtime.baseUrl.trim() ? runtime.baseUrl.trim() : null;
-  const deviceToken = typeof runtime.deviceToken === 'string' && runtime.deviceToken.trim() ? 'set' : 'unset';
+  const baseUrl =
+    typeof runtime.baseUrl === "string" && runtime.baseUrl.trim() ? runtime.baseUrl.trim() : null;
+  const deviceToken =
+    typeof runtime.deviceToken === "string" && runtime.deviceToken.trim() ? "set" : "unset";
   const dashboardUrl =
-    typeof runtime.dashboardUrl === 'string' && runtime.dashboardUrl.trim() ? runtime.dashboardUrl.trim() : null;
-  const httpTimeoutMs = Number.isFinite(Number(runtime.httpTimeoutMs)) ? Number(runtime.httpTimeoutMs) : null;
+    typeof runtime.dashboardUrl === "string" && runtime.dashboardUrl.trim()
+      ? runtime.dashboardUrl.trim()
+      : null;
+  const httpTimeoutMs = Number.isFinite(Number(runtime.httpTimeoutMs))
+    ? Number(runtime.httpTimeoutMs)
+    : null;
   const debug = Boolean(runtime.debug);
-  const insforgeAnonKey = typeof runtime.insforgeAnonKey === 'string' && runtime.insforgeAnonKey.trim() ? 'set' : 'unset';
+  const insforgeAnonKey =
+    typeof runtime.insforgeAnonKey === "string" && runtime.insforgeAnonKey.trim() ? "set" : "unset";
   const autoRetryNoSpawn = Boolean(runtime.autoRetryNoSpawn);
 
   checks.push({
-    id: 'runtime.base_url',
-    status: baseUrl ? 'ok' : 'fail',
-    detail: baseUrl ? 'base_url set' : 'base_url missing',
+    id: "runtime.base_url",
+    status: baseUrl ? "ok" : "fail",
+    detail: baseUrl ? "base_url set" : "base_url missing",
     critical: false,
     meta: {
       base_url: baseUrl,
-      source: runtime?.sources?.baseUrl || null
-    }
+      source: runtime?.sources?.baseUrl || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.device_token',
-    status: deviceToken === 'set' ? 'ok' : 'warn',
-    detail: deviceToken === 'set' ? 'device token set' : 'device token missing',
+    id: "runtime.device_token",
+    status: deviceToken === "set" ? "ok" : "warn",
+    detail: deviceToken === "set" ? "device token set" : "device token missing",
     critical: false,
     meta: {
       device_token: deviceToken,
-      source: runtime?.sources?.deviceToken || null
-    }
+      source: runtime?.sources?.deviceToken || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.dashboard_url',
-    status: 'ok',
-    detail: dashboardUrl ? 'dashboard_url set' : 'dashboard_url unset',
+    id: "runtime.dashboard_url",
+    status: "ok",
+    detail: dashboardUrl ? "dashboard_url set" : "dashboard_url unset",
     critical: false,
     meta: {
       dashboard_url: dashboardUrl,
-      source: runtime?.sources?.dashboardUrl || null
-    }
+      source: runtime?.sources?.dashboardUrl || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.http_timeout_ms',
-    status: 'ok',
-    detail: 'http timeout resolved',
+    id: "runtime.http_timeout_ms",
+    status: "ok",
+    detail: "http timeout resolved",
     critical: false,
     meta: {
       http_timeout_ms: httpTimeoutMs,
-      source: runtime?.sources?.httpTimeoutMs || null
-    }
+      source: runtime?.sources?.httpTimeoutMs || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.debug',
-    status: 'ok',
-    detail: debug ? 'debug enabled' : 'debug disabled',
+    id: "runtime.debug",
+    status: "ok",
+    detail: debug ? "debug enabled" : "debug disabled",
     critical: false,
     meta: {
       debug,
-      source: runtime?.sources?.debug || null
-    }
+      source: runtime?.sources?.debug || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.insforge_anon_key',
-    status: 'ok',
-    detail: insforgeAnonKey === 'set' ? 'anon key set' : 'anon key unset',
+    id: "runtime.insforge_anon_key",
+    status: "ok",
+    detail: insforgeAnonKey === "set" ? "anon key set" : "anon key unset",
     critical: false,
     meta: {
       anon_key: insforgeAnonKey,
-      source: runtime?.sources?.insforgeAnonKey || null
-    }
+      source: runtime?.sources?.insforgeAnonKey || null,
+    },
   });
 
   checks.push({
-    id: 'runtime.auto_retry_no_spawn',
-    status: 'ok',
-    detail: autoRetryNoSpawn ? 'auto retry spawn disabled' : 'auto retry spawn enabled',
+    id: "runtime.auto_retry_no_spawn",
+    status: "ok",
+    detail: autoRetryNoSpawn ? "auto retry spawn disabled" : "auto retry spawn enabled",
     critical: false,
     meta: {
       auto_retry_no_spawn: autoRetryNoSpawn,
-      source: runtime?.sources?.autoRetryNoSpawn || null
-    }
+      source: runtime?.sources?.autoRetryNoSpawn || null,
+    },
   });
 
   return checks;
@@ -138,85 +145,85 @@ async function checkTrackerDir(trackerDir) {
     const st = await fs.stat(trackerDir);
     if (!st.isDirectory()) {
       return {
-        id: 'fs.tracker_dir',
-        status: 'fail',
-        detail: 'tracker dir is not a directory',
+        id: "fs.tracker_dir",
+        status: "fail",
+        detail: "tracker dir is not a directory",
         critical: true,
-        meta: { path: trackerDir }
+        meta: { path: trackerDir },
       };
     }
     await fs.access(trackerDir, constants.R_OK);
     return {
-      id: 'fs.tracker_dir',
-      status: 'ok',
-      detail: 'tracker dir readable',
+      id: "fs.tracker_dir",
+      status: "ok",
+      detail: "tracker dir readable",
       critical: false,
-      meta: { path: trackerDir }
+      meta: { path: trackerDir },
     };
   } catch (err) {
-    if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) {
+    if (err && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
       return {
-        id: 'fs.tracker_dir',
-        status: 'warn',
-        detail: 'tracker dir missing',
+        id: "fs.tracker_dir",
+        status: "warn",
+        detail: "tracker dir missing",
         critical: false,
-        meta: { path: trackerDir }
+        meta: { path: trackerDir },
       };
     }
-    if (err && (err.code === 'EACCES' || err.code === 'EPERM')) {
+    if (err && (err.code === "EACCES" || err.code === "EPERM")) {
       return {
-        id: 'fs.tracker_dir',
-        status: 'fail',
-        detail: 'tracker dir permission denied',
+        id: "fs.tracker_dir",
+        status: "fail",
+        detail: "tracker dir permission denied",
         critical: true,
-        meta: { path: trackerDir, code: err.code }
+        meta: { path: trackerDir, code: err.code },
       };
     }
     return {
-      id: 'fs.tracker_dir',
-      status: 'fail',
-      detail: 'tracker dir error',
+      id: "fs.tracker_dir",
+      status: "fail",
+      detail: "tracker dir error",
       critical: true,
-      meta: { path: trackerDir, code: err?.code || 'error' }
+      meta: { path: trackerDir, code: err?.code || "error" },
     };
   }
 }
 
 async function checkConfigJson(configPath) {
   const res = await readJsonStrict(configPath);
-  if (res.status === 'ok') {
+  if (res.status === "ok") {
     return {
-      id: 'fs.config_json',
-      status: 'ok',
-      detail: 'config.json readable',
+      id: "fs.config_json",
+      status: "ok",
+      detail: "config.json readable",
       critical: false,
-      meta: { path: configPath }
+      meta: { path: configPath },
     };
   }
-  if (res.status === 'missing') {
+  if (res.status === "missing") {
     return {
-      id: 'fs.config_json',
-      status: 'warn',
-      detail: 'config.json missing',
+      id: "fs.config_json",
+      status: "warn",
+      detail: "config.json missing",
       critical: false,
-      meta: { path: configPath }
+      meta: { path: configPath },
     };
   }
-  if (res.status === 'invalid') {
+  if (res.status === "invalid") {
     return {
-      id: 'fs.config_json',
-      status: 'fail',
-      detail: 'config.json invalid',
+      id: "fs.config_json",
+      status: "fail",
+      detail: "config.json invalid",
       critical: true,
-      meta: { path: configPath }
+      meta: { path: configPath },
     };
   }
   return {
-    id: 'fs.config_json',
-    status: 'fail',
-    detail: 'config.json read error',
+    id: "fs.config_json",
+    status: "fail",
+    detail: "config.json read error",
     critical: true,
-    meta: { path: configPath }
+    meta: { path: configPath },
   };
 }
 
@@ -225,31 +232,31 @@ async function checkCliEntrypoint(cliPath) {
     const st = await fs.stat(cliPath);
     if (!st.isFile()) {
       return {
-        id: 'cli.entrypoint',
-        status: 'fail',
-        detail: 'cli entrypoint is not a file',
+        id: "cli.entrypoint",
+        status: "fail",
+        detail: "cli entrypoint is not a file",
         critical: false,
-        meta: { path: cliPath }
+        meta: { path: cliPath },
       };
     }
     await fs.access(cliPath, constants.R_OK);
-    if (process.platform !== 'win32') {
+    if (process.platform !== "win32") {
       await fs.access(cliPath, constants.X_OK);
     }
     return {
-      id: 'cli.entrypoint',
-      status: 'ok',
-      detail: 'cli entrypoint readable',
+      id: "cli.entrypoint",
+      status: "ok",
+      detail: "cli entrypoint readable",
       critical: false,
-      meta: { path: cliPath }
+      meta: { path: cliPath },
     };
   } catch (err) {
     return {
-      id: 'cli.entrypoint',
-      status: 'fail',
-      detail: 'cli entrypoint not accessible',
+      id: "cli.entrypoint",
+      status: "fail",
+      detail: "cli entrypoint not accessible",
       critical: false,
-      meta: { path: cliPath, code: err?.code || 'error' }
+      meta: { path: cliPath, code: err?.code || "error" },
     };
   }
 }
@@ -257,42 +264,42 @@ async function checkCliEntrypoint(cliPath) {
 async function checkNetwork({ baseUrl, fetch }) {
   if (!baseUrl) {
     return {
-      id: 'network.base_url',
-      status: 'warn',
-      detail: 'base_url missing (skipped)',
+      id: "network.base_url",
+      status: "warn",
+      detail: "base_url missing (skipped)",
       critical: false,
-      meta: { base_url: null }
+      meta: { base_url: null },
     };
   }
 
   const start = Date.now();
   try {
-    if (typeof fetch !== 'function') throw new Error('Missing fetch');
-    const res = await fetch(baseUrl, { method: 'GET' });
+    if (typeof fetch !== "function") throw new Error("Missing fetch");
+    const res = await fetch(baseUrl, { method: "GET" });
     const latency = Date.now() - start;
     return {
-      id: 'network.base_url',
-      status: 'ok',
+      id: "network.base_url",
+      status: "ok",
       detail: `HTTP ${res.status} (reachable)`,
       critical: false,
       meta: {
         status_code: res.status,
         latency_ms: latency,
-        base_url: baseUrl
-      }
+        base_url: baseUrl,
+      },
     };
   } catch (err) {
     const latency = Date.now() - start;
     return {
-      id: 'network.base_url',
-      status: 'fail',
-      detail: 'Network error',
+      id: "network.base_url",
+      status: "fail",
+      detail: "Network error",
       critical: false,
       meta: {
         error: err?.message || String(err),
         latency_ms: latency,
-        base_url: baseUrl
-      }
+        base_url: baseUrl,
+      },
     };
   }
 }
@@ -302,28 +309,28 @@ function buildDiagnosticsChecks(diagnostics) {
   const notify = diagnostics?.notify || {};
   const notifyConfigured = Boolean(
     notify.codex_notify_configured ||
-      notify.every_code_notify_configured ||
-      notify.claude_hook_configured ||
-      notify.gemini_hook_configured ||
-      notify.opencode_plugin_configured ||
-      notify.openclaw_hook_configured
+    notify.every_code_notify_configured ||
+    notify.claude_hook_configured ||
+    notify.gemini_hook_configured ||
+    notify.opencode_plugin_configured ||
+    notify.openclaw_hook_configured,
   );
 
   checks.push({
-    id: 'notify.configured',
-    status: notifyConfigured ? 'ok' : 'warn',
-    detail: notifyConfigured ? 'notify configured' : 'notify not configured',
+    id: "notify.configured",
+    status: notifyConfigured ? "ok" : "warn",
+    detail: notifyConfigured ? "notify configured" : "notify not configured",
     critical: false,
-    meta: { configured: notifyConfigured }
+    meta: { configured: notifyConfigured },
   });
 
   const uploadError = diagnostics?.upload?.last_error || null;
   checks.push({
-    id: 'upload.last_error',
-    status: uploadError ? 'warn' : 'ok',
-    detail: uploadError ? 'last upload error present' : 'no upload errors',
+    id: "upload.last_error",
+    status: uploadError ? "warn" : "ok",
+    detail: uploadError ? "last upload error present" : "no upload errors",
     critical: false,
-    meta: { last_error: uploadError ? uploadError.message || null : null }
+    meta: { last_error: uploadError ? uploadError.message || null : null },
   });
 
   return checks;
@@ -332,11 +339,11 @@ function buildDiagnosticsChecks(diagnostics) {
 function summarizeChecks(checks = []) {
   const summary = { ok: 0, warn: 0, fail: 0, critical: 0 };
   for (const check of checks) {
-    if (!check || typeof check.status !== 'string') continue;
-    if (check.status === 'ok') summary.ok += 1;
-    else if (check.status === 'warn') summary.warn += 1;
-    else if (check.status === 'fail') summary.fail += 1;
-    if (check.status === 'fail' && check.critical) summary.critical += 1;
+    if (!check || typeof check.status !== "string") continue;
+    if (check.status === "ok") summary.ok += 1;
+    else if (check.status === "warn") summary.warn += 1;
+    else if (check.status === "fail") summary.fail += 1;
+    if (check.status === "fail" && check.critical) summary.critical += 1;
   }
   return summary;
 }

package/src/lib/fs.js

@@ -1,5 +1,5 @@
-const fs = require('node:fs/promises');
-const path = require('node:path');
+const fs = require("node:fs/promises");
+const path = require("node:path");
 
 async function ensureDir(p) {
   await fs.mkdir(p, { recursive: true });
@@ -9,13 +9,13 @@ async function writeFileAtomic(filePath, content) {
   const dir = path.dirname(filePath);
   await ensureDir(dir);
   const tmp = `${filePath}.tmp.${Date.now()}`;
-  await fs.writeFile(tmp, content, { encoding: 'utf8' });
+  await fs.writeFile(tmp, content, { encoding: "utf8" });
   await fs.rename(tmp, filePath);
 }
 
 async function readJson(filePath) {
   try {
-    const raw = await fs.readFile(filePath, 'utf8');
+    const raw = await fs.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch (_e) {
     return null;
@@ -24,21 +24,21 @@ async function readJson(filePath) {
 
 async function readJsonStrict(filePath) {
   try {
-    const raw = await fs.readFile(filePath, 'utf8');
-    return { status: 'ok', value: JSON.parse(raw), error: null };
+    const raw = await fs.readFile(filePath, "utf8");
+    return { status: "ok", value: JSON.parse(raw), error: null };
   } catch (err) {
-    if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) {
-      return { status: 'missing', value: null, error: err };
+    if (err && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
+      return { status: "missing", value: null, error: err };
     }
-    if (err && err.name === 'SyntaxError') {
-      return { status: 'invalid', value: null, error: err };
+    if (err && err.name === "SyntaxError") {
+      return { status: "invalid", value: null, error: err };
     }
-    return { status: 'error', value: null, error: err };
+    return { status: "error", value: null, error: err };
   }
 }
 
 async function writeJson(filePath, obj) {
-  await writeFileAtomic(filePath, JSON.stringify(obj, null, 2) + '\n');
+  await writeFileAtomic(filePath, JSON.stringify(obj, null, 2) + "\n");
 }
 
 async function chmod600IfPossible(filePath) {
@@ -49,16 +49,16 @@ async function chmod600IfPossible(filePath) {
 
 async function openLock(lockPath, { quietIfLocked }) {
   try {
-    const handle = await fs.open(lockPath, 'wx');
+    const handle = await fs.open(lockPath, "wx");
     return {
       async release() {
         await handle.close().catch(() => {});
-      }
+      },
     };
   } catch (e) {
-    if (e && e.code === 'EEXIST') {
+    if (e && e.code === "EEXIST") {
       if (!quietIfLocked) {
-        process.stdout.write('Another sync is already running.\n');
+        process.stdout.write("Another sync is already running.\n");
       }
       return null;
     }
@@ -73,5 +73,5 @@ module.exports = {
   readJsonStrict,
   writeJson,
   chmod600IfPossible,
-  openLock
+  openLock,
 };