vibeusage 0.3.1 → 0.3.2

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,
-  };
-}

package/src/lib/openclaw-hook.js

@@ -1,420 +0,0 @@
-const os = require("node:os");
-const path = require("node:path");
-const fs = require("node:fs/promises");
-const fssync = require("node:fs");
-const cp = require("node:child_process");
-
-const OPENCLAW_HOOK_NAME = "vibeusage-openclaw-sync";
-const OPENCLAW_HOOK_DIRNAME = "openclaw-hook";
-
-function resolveOpenclawHookPaths({ home = os.homedir(), trackerDir, env = process.env } = {}) {
-  if (!trackerDir) throw new Error("trackerDir is required");
-
-  const openclawConfigPath =
-    normalizeString(env.OPENCLAW_CONFIG_PATH) || path.join(home, ".openclaw", "openclaw.json");
-
-  const openclawHome =
-    normalizeString(env.VIBEUSAGE_OPENCLAW_HOME) ||
-    normalizeString(env.OPENCLAW_STATE_DIR) ||
-    path.join(home, ".openclaw");
-
-  const hookDir = path.join(trackerDir, OPENCLAW_HOOK_DIRNAME);
-  const hookEntryDir = path.join(hookDir, OPENCLAW_HOOK_NAME);
-
-  return {
-    hookName: OPENCLAW_HOOK_NAME,
-    hookDir,
-    hookEntryDir,
-    openclawConfigPath,
-    openclawHome,
-  };
-}
-
-async function installOpenclawHook({
-  home = os.homedir(),
-  trackerDir,
-  packageName = "vibeusage",
-  env = process.env,
-} = {}) {
-  const paths = resolveOpenclawHookPaths({ home, trackerDir, env });
-
-  await ensureOpenclawHookFiles({
-    hookDir: paths.hookDir,
-    trackerDir,
-    packageName,
-    openclawHome: paths.openclawHome,
-  });
-
-  const installResult = runOpenclawCli(["hooks", "install", "--link", paths.hookDir], env);
-  if (installResult.skippedReason) {
-    return { configured: false, ...paths, ...installResult };
-  }
-
-  const state = await probeOpenclawHookState({ home, trackerDir, env });
-  return {
-    configured: state.configured,
-    changed: /Linked hook path:/i.test(installResult.stdout || ""),
-    ...paths,
-    stdout: installResult.stdout,
-    stderr: installResult.stderr,
-    code: installResult.code,
-  };
-}
-
-async function ensureOpenclawHookFiles({
-  hookDir,
-  trackerDir,
-  packageName = "vibeusage",
-  openclawHome,
-} = {}) {
-  if (!hookDir || !trackerDir) throw new Error("hookDir and trackerDir are required");
-
-  const hookEntryDir = path.join(hookDir, OPENCLAW_HOOK_NAME);
-  await fs.mkdir(hookEntryDir, { recursive: true });
-
-  const hookMdPath = path.join(hookEntryDir, "HOOK.md");
-  const handlerPath = path.join(hookEntryDir, "handler.js");
-
-  await fs.writeFile(hookMdPath, buildHookMarkdown(), "utf8");
-  await fs.writeFile(
-    handlerPath,
-    buildHookHandler({
-      trackerDir,
-      packageName,
-      openclawHome: openclawHome || path.join(os.homedir(), ".openclaw"),
-    }),
-    "utf8",
-  );
-}
-
-async function probeOpenclawHookState({ home = os.homedir(), trackerDir, env = process.env } = {}) {
-  const paths = resolveOpenclawHookPaths({ home, trackerDir, env });
-  const { openclawConfigPath, hookDir, hookEntryDir, hookName } = paths;
-
-  const hookFilesReady =
-    fssync.existsSync(path.join(hookEntryDir, "HOOK.md")) &&
-    fssync.existsSync(path.join(hookEntryDir, "handler.js"));
-
-  let cfg = null;
-  try {
-    const raw = await fs.readFile(openclawConfigPath, "utf8");
-    cfg = JSON.parse(raw);
-  } catch (err) {
-    if (err?.code === "ENOENT" || err?.code === "ENOTDIR") {
-      return {
-        configured: false,
-        enabled: false,
-        linked: false,
-        hookFilesReady,
-        skippedReason: "openclaw-config-missing",
-        ...paths,
-      };
-    }
-    return {
-      configured: false,
-      enabled: false,
-      linked: false,
-      hookFilesReady,
-      skippedReason: "openclaw-config-unreadable",
-      error: err?.message || String(err),
-      ...paths,
-    };
-  }
-
-  const enabled = Boolean(cfg?.hooks?.internal?.entries?.[hookName]?.enabled);
-  const extraDirs = Array.isArray(cfg?.hooks?.internal?.load?.extraDirs)
-    ? cfg.hooks.internal.load.extraDirs
-    : [];
-  const normalizedHookDir = path.resolve(hookDir);
-  const linked = extraDirs.some((entry) => path.resolve(String(entry || "")) === normalizedHookDir);
-
-  return {
-    configured: enabled && linked,
-    enabled,
-    linked,
-    hookFilesReady,
-    ...paths,
-  };
-}
-
-async function removeOpenclawHookConfig({
-  home = os.homedir(),
-  trackerDir,
-  env = process.env,
-} = {}) {
-  const paths = resolveOpenclawHookPaths({ home, trackerDir, env });
-  const { openclawConfigPath, hookDir, hookName } = paths;
-
-  let cfg;
-  try {
-    cfg = JSON.parse(await fs.readFile(openclawConfigPath, "utf8"));
-  } catch (err) {
-    if (err?.code === "ENOENT" || err?.code === "ENOTDIR") {
-      return { removed: false, skippedReason: "openclaw-config-missing", ...paths };
-    }
-    return {
-      removed: false,
-      skippedReason: "openclaw-config-unreadable",
-      error: err?.message || String(err),
-      ...paths,
-    };
-  }
-
-  let changed = false;
-  const hooks = cfg?.hooks;
-  const internal = hooks?.internal;
-
-  if (internal?.entries && Object.prototype.hasOwnProperty.call(internal.entries, hookName)) {
-    delete internal.entries[hookName];
-    changed = true;
-    if (Object.keys(internal.entries).length === 0) delete internal.entries;
-  }
-
-  if (internal?.load && Array.isArray(internal.load.extraDirs)) {
-    const before = internal.load.extraDirs;
-    const target = path.resolve(hookDir);
-    const after = before.filter((entry) => path.resolve(String(entry || "")) !== target);
-    if (after.length !== before.length) {
-      internal.load.extraDirs = after;
-      changed = true;
-      if (after.length === 0) delete internal.load.extraDirs;
-      if (Object.keys(internal.load).length === 0) delete internal.load;
-    }
-  }
-
-  if (internal?.installs && typeof internal.installs === "object") {
-    const installs = internal.installs;
-    if (Object.prototype.hasOwnProperty.call(installs, hookName)) {
-      delete installs[hookName];
-      changed = true;
-    }
-
-    const target = path.resolve(hookDir);
-    for (const [id, entry] of Object.entries(installs)) {
-      const sourcePath = normalizeString(entry?.sourcePath);
-      const installPath = normalizeString(entry?.installPath);
-      if (
-        (sourcePath && path.resolve(sourcePath) === target) ||
-        (installPath && path.resolve(installPath) === target)
-      ) {
-        delete installs[id];
-        changed = true;
-      }
-    }
-
-    if (Object.keys(installs).length === 0) delete internal.installs;
-  }
-
-  if (internal && Object.keys(internal).length === 0) {
-    delete hooks.internal;
-    changed = true;
-  }
-  if (hooks && Object.keys(hooks).length === 0) {
-    delete cfg.hooks;
-    changed = true;
-  }
-
-  if (changed) {
-    await fs.writeFile(openclawConfigPath, `${JSON.stringify(cfg, null, 2)}\n`, "utf8");
-  }
-
-  await fs.rm(hookDir, { recursive: true, force: true }).catch(() => {});
-
-  return { removed: changed, ...paths };
-}
-
-function runOpenclawCli(args, env = process.env) {
-  let res;
-  try {
-    res = cp.spawnSync("openclaw", args, {
-      env,
-      encoding: "utf8",
-      timeout: 30_000,
-    });
-  } catch (err) {
-    return {
-      code: 1,
-      skippedReason: err?.code === "ENOENT" ? "openclaw-cli-missing" : "openclaw-cli-error",
-      error: err?.message || String(err),
-      stdout: "",
-      stderr: "",
-    };
-  }
-
-  if (res.error?.code === "ENOENT") {
-    return {
-      code: 1,
-      skippedReason: "openclaw-cli-missing",
-      error: res.error.message,
-      stdout: res.stdout || "",
-      stderr: res.stderr || "",
-    };
-  }
-
-  if ((res.status || 0) !== 0) {
-    return {
-      code: Number(res.status || 1),
-      skippedReason: "openclaw-hooks-install-failed",
-      error: (res.stderr || res.stdout || "").trim() || "openclaw hooks install failed",
-      stdout: res.stdout || "",
-      stderr: res.stderr || "",
-    };
-  }
-
-  return {
-    code: 0,
-    stdout: res.stdout || "",
-    stderr: res.stderr || "",
-  };
-}
-
-function buildHookMarkdown() {
-  return `---
-name: ${OPENCLAW_HOOK_NAME}
-description: "Trigger vibeusage sync when OpenClaw sessions roll over"
-metadata:
-  { "openclaw": { "emoji": "📈", "events": ["command:new", "command:reset", "command:stop"], "requires": { "bins": ["node"] } } }
----
-
-# VibeUsage OpenClaw Sync Hook
-
-Triggers non-blocking 'vibeusage sync --auto --from-openclaw' runs when OpenClaw command events indicate session rollover/reset/stop.
-`;
-}
-
-function buildHookHandler({ trackerDir, packageName = "vibeusage", openclawHome }) {
-  const trackerBinPath = path.join(trackerDir, "app", "bin", "tracker.js");
-  const fallbackPkg = packageName || "vibeusage";
-  const safeOpenclawHome = openclawHome || path.join(os.homedir(), ".openclaw");
-
-  return (
-    `'use strict';\n` +
-    `const fs = require('node:fs');\n` +
-    `const path = require('node:path');\n` +
-    `const cp = require('node:child_process');\n` +
-    `const trackerDir = ${JSON.stringify(trackerDir)};\n` +
-    `const trackerBinPath = ${JSON.stringify(trackerBinPath)};\n` +
-    `const fallbackPkg = ${JSON.stringify(fallbackPkg)};\n` +
-    `const openclawHome = ${JSON.stringify(safeOpenclawHome)};\n` +
-    `const throttlePath = path.join(trackerDir, 'openclaw.sync.throttle');\n` +
-    `const depsMarkerPath = path.join(trackerDir, 'app', 'node_modules', '@insforge', 'sdk', 'package.json');\n` +
-    `const THROTTLE_MS = 15_000;\n` +
-    `\n` +
-    `module.exports = async function handler(event) {\n` +
-    `  try {\n` +
-    `    if (!event || event.type !== 'command') return;\n` +
-    `    if (event.action !== 'new' && event.action !== 'reset' && event.action !== 'stop') return;\n` +
-    `\n` +
-    `    const sessionKey = normalize(event.sessionKey);\n` +
-    `    const agentId = parseAgentId(sessionKey);\n` +
-    `    if (!agentId) return;\n` +
-    `\n` +
-    `    const sessionEntry = resolveSessionEntry(event);\n` +
-    `    const sessionId = normalize(sessionEntry && sessionEntry.sessionId) || resolveSessionId(event);\n` +
-    `    if (!sessionId) return;\n` +
-    `\n` +
-    `    const now = Date.now();\n` +
-    `    let last = 0;\n` +
-    `    try { last = Number(fs.readFileSync(throttlePath, 'utf8')) || 0; } catch (_) {}\n` +
-    `    if (now - last < THROTTLE_MS) return;\n` +
-    `    try {\n` +
-    `      fs.mkdirSync(trackerDir, { recursive: true });\n` +
-    `      fs.writeFileSync(throttlePath, String(now), 'utf8');\n` +
-    `    } catch (_) {}\n` +
-    `\n` +
-    `    const env = {\n` +
-    `      ...process.env,\n` +
-    `      VIBEUSAGE_OPENCLAW_AGENT_ID: agentId,\n` +
-    `      VIBEUSAGE_OPENCLAW_SESSION_KEY: sessionKey,\n` +
-    `      VIBEUSAGE_OPENCLAW_PREV_SESSION_ID: sessionId,\n` +
-    `      VIBEUSAGE_OPENCLAW_HOME: openclawHome\n` +
-    `    };\n` +
-    `    const prevTotalTokens = toNonNegativeInt(sessionEntry && sessionEntry.totalTokens);\n` +
-    `    const prevInputTokens = toNonNegativeInt(sessionEntry && sessionEntry.inputTokens);\n` +
-    `    const prevOutputTokens = toNonNegativeInt(sessionEntry && sessionEntry.outputTokens);\n` +
-    `    const prevModel = normalize(sessionEntry && sessionEntry.model);\n` +
-    `    const prevUpdatedAt = toIso(sessionEntry && sessionEntry.updatedAt);\n` +
-    `    if (prevTotalTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_TOTAL_TOKENS = String(prevTotalTokens);\n` +
-    `    if (prevInputTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_INPUT_TOKENS = String(prevInputTokens);\n` +
-    `    if (prevOutputTokens != null) env.VIBEUSAGE_OPENCLAW_PREV_OUTPUT_TOKENS = String(prevOutputTokens);\n` +
-    `    if (prevModel) env.VIBEUSAGE_OPENCLAW_PREV_MODEL = prevModel;\n` +
-    `    if (prevUpdatedAt) env.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT = prevUpdatedAt;\n` +
-    `\n` +
-    `    const hasLocalRuntime = fs.existsSync(trackerBinPath);\n` +
-    `    const hasLocalDeps = fs.existsSync(depsMarkerPath);\n` +
-    `    const cmd = hasLocalRuntime && hasLocalDeps\n` +
-    `      ? [process.execPath, trackerBinPath, 'sync', '--auto', '--from-openclaw']\n` +
-    `      : ['npx', '--yes', fallbackPkg, 'sync', '--auto', '--from-openclaw'];\n` +
-    `\n` +
-    `    const child = cp.spawn(cmd[0], cmd.slice(1), { detached: true, stdio: 'ignore', env });\n` +
-    `    child.unref();\n` +
-    `  } catch (_) {}\n` +
-    `};\n` +
-    `\n` +
-    `function normalize(v) {\n` +
-    `  if (typeof v !== 'string') return null;\n` +
-    `  const s = v.trim();\n` +
-    `  return s.length > 0 ? s : null;\n` +
-    `}\n` +
-    `\n` +
-    `function resolveSessionEntry(event) {\n` +
-    `  const ctx = (event && event.context && typeof event.context === 'object') ? event.context : {};\n` +
-    `  if (!event || event.type !== 'command') return null;\n` +
-    `  if (event.action === 'stop') return (ctx.sessionEntry && typeof ctx.sessionEntry === 'object') ? ctx.sessionEntry : null;\n` +
-    `  if (ctx.previousSessionEntry && typeof ctx.previousSessionEntry === 'object') return ctx.previousSessionEntry;\n` +
-    `  if (ctx.sessionEntry && typeof ctx.sessionEntry === 'object') return ctx.sessionEntry;\n` +
-    `  return null;\n` +
-    `}\n` +
-    `\n` +
-    `function toNonNegativeInt(v) {\n` +
-    `  const n = Number(v);\n` +
-    `  if (!Number.isFinite(n) || n < 0) return null;\n` +
-    `  return Math.floor(n);\n` +
-    `}\n` +
-    `\n` +
-    `function toIso(v) {\n` +
-    `  if (typeof v === 'string') {\n` +
-    `    const s = normalize(v);\n` +
-    `    if (s && !Number.isNaN(Date.parse(s))) return s;\n` +
-    `  }\n` +
-    `  const n = Number(v);\n` +
-    `  if (!Number.isFinite(n) || n <= 0) return null;\n` +
-    `  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);\n` +
-    `  const d = new Date(ms);\n` +
-    `  return Number.isNaN(d.getTime()) ? null : d.toISOString();\n` +
-    `}\n` +
-    `\n` +
-    `function parseAgentId(sessionKey) {\n` +
-    `  const s = normalize(sessionKey);\n` +
-    `  if (!s || !s.startsWith('agent:')) return null;\n` +
-    `  const parts = s.split(':');\n` +
-    `  return parts.length >= 2 ? normalize(parts[1]) : null;\n` +
-    `}\n` +
-    `\n` +
-    `function resolveSessionId(event) {\n` +
-    `  const ctx = (event && event.context && typeof event.context === 'object') ? event.context : {};\n` +
-    `  return (\n` +
-    `    normalize(ctx.previousSessionEntry && ctx.previousSessionEntry.sessionId) ||\n` +
-    `    normalize(ctx.previousSessionId) ||\n` +
-    `    normalize(ctx.sessionEntry && ctx.sessionEntry.sessionId) ||\n` +
-    `    normalize(ctx.sessionId)\n` +
-    `  );\n` +
-    `}\n`
-  );
-}
-
-function normalizeString(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-module.exports = {
-  OPENCLAW_HOOK_NAME,
-  OPENCLAW_HOOK_DIRNAME,
-  resolveOpenclawHookPaths,
-  ensureOpenclawHookFiles,
-  installOpenclawHook,
-  probeOpenclawHookState,
-  removeOpenclawHookConfig,
-};