vibeusage 0.2.22 → 0.3.0

package/src/lib/integrations/index.js

@@ -0,0 +1,85 @@
+const { createIntegrationContext } = require("./context");
+const codex = require("./codex");
+const everyCode = require("./every-code");
+const claude = require("./claude");
+const gemini = require("./gemini");
+const opencode = require("./opencode");
+const openclawSession = require("./openclaw-session");
+const openclawLegacy = require("./openclaw-legacy");
+
+const INTEGRATIONS = [
+  codex,
+  everyCode,
+  claude,
+  gemini,
+  opencode,
+  openclawSession,
+  openclawLegacy,
+];
+
+function listIntegrations() {
+  return INTEGRATIONS.slice();
+}
+
+async function probeIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.probe(ctx));
+  }
+  return results;
+}
+
+async function installIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.install(ctx));
+  }
+  return results;
+}
+
+async function uninstallIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.uninstall(ctx));
+  }
+  return results;
+}
+
+function summarizeProbeForInitPreview(probe) {
+  switch (probe.status) {
+    case "ready":
+      return { label: probe.summaryLabel, status: "set", detail: "Already configured" };
+    case "not_installed":
+      if (probe.initPreviewStatus) {
+        return {
+          label: probe.summaryLabel,
+          status: probe.initPreviewStatus,
+          detail: probe.initPreviewDetail || probe.detail,
+        };
+      }
+      return { label: probe.summaryLabel, status: "skipped", detail: probe.detail };
+    case "unsupported_legacy":
+      return { label: probe.summaryLabel, status: "updated", detail: "Will replace legacy config" };
+    case "unreadable":
+      return { label: probe.summaryLabel, status: "skipped", detail: probe.detail || "Config unreadable" };
+    default:
+      return { label: probe.summaryLabel, status: "updated", detail: "Will reconcile config" };
+  }
+}
+
+async function ensureContext(context) {
+  if (context?.trackerPaths && context?.notifyPath) return context;
+  return createIntegrationContext(context);
+}
+
+module.exports = {
+  listIntegrations,
+  createIntegrationContext,
+  probeIntegrations,
+  installIntegrations,
+  uninstallIntegrations,
+  summarizeProbeForInitPreview,
+};

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

@@ -0,0 +1,123 @@
+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/integrations/openclaw-session.js

@@ -0,0 +1,132 @@
+const {
+  installOpenclawSessionPlugin,
+  probeOpenclawSessionPluginState,
+  removeOpenclawSessionPluginConfig,
+} = require("../openclaw-session-plugin");
+
+module.exports = {
+  name: "openclaw-session",
+  summaryLabel: "OpenClaw Session Plugin",
+  statusLabel: "OpenClaw session plugin",
+  async probe(ctx) {
+    const state = await probeOpenclawSessionPluginState({
+      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) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Session plugin linked",
+        configured: true,
+        linked: Boolean(state.linked),
+        enabled: Boolean(state.enabled),
+      });
+    }
+    return baseProbe(this, {
+      status: "drifted",
+      detail: "Run vibeusage init to reconcile session plugin",
+      linked: Boolean(state?.linked),
+      enabled: Boolean(state?.enabled),
+    });
+  },
+  async install(ctx) {
+    const before = await probeOpenclawSessionPluginState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    const result = await installOpenclawSessionPlugin({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      packageName: "vibeusage",
+      env: ctx.env,
+    });
+    if (result?.skippedReason === "openclaw-cli-missing") {
+      return action(this, "skipped", false, "OpenClaw CLI not found");
+    }
+    if (result?.skippedReason === "openclaw-plugins-install-failed") {
+      return action(this, "skipped", false, `Install failed: ${result.error || "unknown error"}`);
+    }
+    if (result?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        result.error ? `OpenClaw config unreadable: ${result.error}` : "OpenClaw config unreadable",
+      );
+    }
+    return action(
+      this,
+      before?.configured ? "set" : "installed",
+      Boolean(!before?.configured && result?.configured),
+      before?.configured
+        ? "Session plugin already linked"
+        : "Session plugin linked (restart OpenClaw gateway to activate)",
+    );
+  },
+  async uninstall(ctx) {
+    const result = await removeOpenclawSessionPluginConfig({
+      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 === "ready") return "set";
+    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/integrations/opencode.js

@@ -0,0 +1,86 @@
+const { isOpencodePluginInstalled, upsertOpencodePlugin, removeOpencodePlugin } = require("../opencode-config");
+const { isDir } = require("./utils");
+
+module.exports = {
+  name: "opencode",
+  summaryLabel: "Opencode Plugin",
+  statusLabel: "Opencode plugin",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.opencode.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "Config not found",
+        initPreviewStatus: "updated",
+        initPreviewDetail: "Will install plugin",
+      });
+    }
+    const configured = await isOpencodePluginInstalled({ configDir: ctx.opencode.configDir });
+    return baseProbe(this, {
+      status: configured ? "ready" : "drifted",
+      detail: configured ? "Plugin installed" : "Run vibeusage init to reconcile plugin",
+      configured,
+    });
+  },
+  async install(ctx) {
+    const result = await upsertOpencodePlugin({
+      configDir: ctx.opencode.configDir,
+      notifyPath: ctx.notifyPath,
+    });
+    if (result?.skippedReason === "config-missing") {
+      return action(this, "skipped", false, "Config not found");
+    }
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Plugin installed" : "Plugin already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.opencode.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeOpencodePlugin({ configDir: ctx.opencode.configDir });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.opencode.configDir);
+    }
+    if (result.skippedReason === "plugin-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result.skippedReason === "unexpected-content") {
+      return action(this, "skipped", false, "unexpected content", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "config dir not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    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/integrations/utils.js

@@ -0,0 +1,39 @@
+const fs = require("node:fs/promises");
+
+async function isFile(targetPath) {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+
+async function isDir(targetPath) {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isDirectory();
+  } catch (_err) {
+    return false;
+  }
+}
+
+function arraysEqual(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i += 1) {
+    if (String(left[i]) !== String(right[i])) return false;
+  }
+  return true;
+}
+
+function findIntegration(results, name) {
+  return Array.isArray(results) ? results.find((entry) => entry?.name === name) || null : null;
+}
+
+module.exports = {
+  isFile,
+  isDir,
+  arraysEqual,
+  findIntegration,
+};

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,6 +1,10 @@
 "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 });
@@ -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",
@@ -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,
+};