@nexusbloom/cli 0.2.12 → 0.3.0

package/src/tools.js

@@ -0,0 +1,561 @@
+/**
+ * tools.js — Centralised tool catalogue for the nxb CLI.
+ *
+ * Resolution order for the *tool list*:
+ *   1. Cached snapshot  (`.cache/tools-list.json`) — always written on a
+ *      successful fetch so subsequent `list` / `abbr` calls are offline-fast.
+ *   2. Live API          (`/api/tools`)
+ *   3. Supabase fallback (`/rest/v1/tools` + `/rest/v1/community_tools`)
+ *   4. Local filesystem scan (`src/tools/<slug>/v2.js`)
+ *
+ * Resolution order for a *single tool's source* (for `--local` execution):
+ *   1. Local filesystem  → 2. cache (`tools/<slug>.json`) → 3. API/Supabase
+ *
+ * Exports:
+ *   loadConfig / saveConfig / configGet / configSet
+ *   fetchTools()              — resolves list (cache-first on network failure)
+ *   refreshTools()            — force a fresh fetch + persist to cache
+ *   fetchToolSource(slug)     — { manifest, coreLogicSource }
+ *   scanLocalTools()
+ *   findLocalTool(slug)
+ *   generateAbbreviations(slugs)
+ *   resolveToolSlug(slug, tools?)
+ *   getSupabaseKey / getSupabaseUrl / supabaseHeaders
+ *   API_BASE
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+import {
+  CONFIG_DIR,
+  CONFIG_PATH,
+  ensureConfigDir,
+  ensureCacheDir,
+  TOOLS_CACHE_DIR,
+  TOOLS_LIST_CACHE_PATH,
+} from "./paths.js";
+import chalk from "chalk";
+
+const require = createRequire(import.meta.url);
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+export const API_BASE = process.env.NEXUSBLOOM_API_URL || "https://www.nexusbloom.dev";
+
+const SUPABASE_URL_DEFAULT = "https://dhxaqatmuprehrkszxzs.supabase.co";
+const SUPABASE_ANON_KEY_DEFAULT =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImRoeGFxYXRtdXByZWhya3N6eHpzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzMxNjIzNTQsImV4cCI6MjA4ODczODM1NH0.pq7DxW66ETQt6QlIAu2WiLO08tfA7JHQVPd2SvvA3sM";
+
+// Cache freshness threshold (30 min)
+const CACHE_TTL_MS = 30 * 60 * 1000;
+
+// Common local-tool search roots (relative to CWD)
+const LOCAL_TOOL_DIRS = [
+  "src/tools",
+  "tools",
+  "apps/main-site/frontend/src/tools",
+];
+
+// ─── Config helpers ─────────────────────────────────────────────────────────
+
+export function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    }
+  } catch {
+    /* corrupt config — ignore */
+  }
+  return {};
+}
+
+export function saveConfig(store = {}) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(store, null, 2), "utf-8");
+}
+
+export function configGet(key) {
+  const store = loadConfig();
+  return key ? store[key] : store;
+}
+
+export function configSet(key, value) {
+  const store = loadConfig();
+  store[key] = value;
+  saveConfig(store);
+}
+
+// ─── Supabase helpers ───────────────────────────────────────────────────────
+
+export function getSupabaseKey() {
+  return process.env.NEXUSBLOOM_SUPABASE_ANON_KEY || configGet("supabaseKey") || SUPABASE_ANON_KEY_DEFAULT;
+}
+
+export function getSupabaseUrl() {
+  return process.env.NEXUSBLOOM_SUPABASE_URL || SUPABASE_URL_DEFAULT;
+}
+
+export function supabaseHeaders(extra = {}) {
+  const key = getSupabaseKey();
+  return { apikey: key, Authorization: `Bearer ${key}`, ...extra };
+}
+
+// ─── Tools list cache (tools-list.json) ──────────────────────────────────────
+
+/**
+ * Read the cached tools-list snapshot from disk.
+ * Returns null if missing, corrupt, or stale (older than CACHE_TTL_MS).
+ */
+export function loadToolsCache(allowStale = false) {
+  try {
+    if (!fs.existsSync(TOOLS_LIST_CACHE_PATH)) return null;
+    const raw = fs.readFileSync(TOOLS_LIST_CACHE_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    const age = Date.now() - (data.cachedAt ? new Date(data.cachedAt).getTime() : 0);
+    if (!allowStale && age > CACHE_TTL_MS) return null;
+    const tools = data.tools;
+    if (!Array.isArray(tools) || tools.length === 0) return null;
+    return tools.map(normalizeTool);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist a tools array to `tools-list.json` so future calls are offline-fast.
+ */
+export function saveToolsCache(tools) {
+  ensureCacheDir();
+  fs.writeFileSync(
+    TOOLS_LIST_CACHE_PATH,
+    JSON.stringify({ tools, cachedAt: new Date().toISOString() }, null, 2),
+    "utf-8"
+  );
+}
+
+// ─── Fetching ───────────────────────────────────────────────────────────────
+
+/**
+ * Fetch the tool list from the live API.
+ * Normalises to the standard shape: { slug, name, description, short_description,
+ * category, runtime, version, icon, type, tags }.
+ */
+async function fetchToolsFromAPI() {
+  try {
+    const url = new URL("/api/tools", API_BASE);
+    const res = await fetch(url);
+    const ct = res.headers.get("content-type") || "";
+    if (ct.includes("json")) {
+      const { tools } = await res.json();
+      if (Array.isArray(tools) && tools.length > 0) {
+        return tools.map(normalizeTool);
+      }
+    }
+  } catch {
+    /* API unreachable */
+  }
+  return null;
+}
+
+/** Normalise a raw tool object to the standard shape. */
+function normalizeTool(t) {
+  if (!t || typeof t !== "object") return t;
+  const desc = t.short_description || t.description || "";
+  return {
+    slug: t.slug || "",
+    name: t.name || t.slug || "",
+    description: desc,
+    short_description: desc,
+    category: t.category || t.tool_type || "uncategorized",
+    runtime: t.runtime || "both",
+    version: t.version || "1.0.0",
+    icon: t.icon || "🔧",
+    type: t.type === "builtin" || t.type === "community" || t.type === "local" ? t.type : "builtin",
+    tags: t.tags || [],
+    ...(t.author_id ? { author_id: t.author_id } : {}),
+    ...(t.price_type ? { price_type: t.price_type } : {}),
+  };
+}
+
+/**
+ * Fetch builtin + community tools from Supabase directly (fallback).
+ * Normalises to the same shape the API returns.
+ */
+async function fetchToolsFromSupabase() {
+  const headers = supabaseHeaders();
+  const supabaseUrl = getSupabaseUrl();
+  try {
+    const builtinRes = await fetch(
+      `${supabaseUrl}/rest/v1/tools?select=slug,name,short_description,tool_type,runtime,version,icon&published=eq.true&order=name.asc`,
+      { headers }
+    );
+    if (!builtinRes.ok) return null;
+    const builtins = await builtinRes.json();
+    if (!Array.isArray(builtins)) return null;
+
+    const communityRes = await fetch(
+      `${supabaseUrl}/rest/v1/community_tools?select=slug,name,short_description,category,version,icon,author_id&status=eq.published&order=name.asc`,
+      { headers }
+    );
+    const community = communityRes.ok ? await communityRes.json() : [];
+
+    return [
+      ...builtins.map((t) => ({
+        slug: t.slug,
+        name: t.name,
+        description: t.short_description || "",
+        short_description: t.short_description || "",
+        category: t.tool_type || "uncategorized",
+        runtime: t.runtime || "both",
+        version: t.version || "1.0.0",
+        icon: t.icon || "🔧",
+        type: "builtin",
+      })),
+      ...(Array.isArray(community)
+        ? community.map((t) => ({
+            slug: t.slug,
+            name: t.name,
+            description: t.short_description || "",
+            short_description: t.short_description || "",
+            category: t.category || "uncategorized",
+            runtime: "both",
+            version: t.version || "1.0.0",
+            icon: t.icon || "🛠️",
+            type: "community",
+            author_id: t.author_id,
+          }))
+        : []),
+    ];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Public entry: resolve the full tool list.
+ *
+ *   fetchTools({ force, offline } = {})
+ *
+ *   - `force`  → bypass cache, hit network, persist result
+ *   - `offline`→ never touch the network, return cache (or local scan) only
+ */
+export async function fetchTools({ force = false, offline = false } = {}) {
+  // 1. If we have a fresh cache and aren't forcing, return it (merge local scan)
+  if (!force && !offline) {
+    const cached = loadToolsCache();
+    if (cached) return mergeLocalTools(cached);
+  }
+
+  // 2. Offline-only mode — cache then local scan
+  if (offline) {
+    const cached = loadToolsCache(true);
+    if (cached) return mergeLocalTools(cached);
+    return mergeLocalTools(scanLocalTools());
+  }
+
+  // 3. Try API → Supabase, persist to cache on success
+  let tools = (await fetchToolsFromAPI()) || (await fetchToolsFromSupabase());
+  if (tools && tools.length > 0) {
+    saveToolsCache(tools);
+    return mergeLocalTools(tools);
+  }
+
+  // 4. Network failed entirely — fall back to stale cache or local scan
+  const cached = loadToolsCache(true);
+  if (cached) return mergeLocalTools(cached);
+  return mergeLocalTools(scanLocalTools());
+}
+
+/**
+ * Convenience: always refresh / re-fetch + re-cache.
+ */
+export async function refreshTools() {
+  const tools = (await fetchToolsFromAPI()) || (await fetchToolsFromSupabase()) || [];
+  if (tools.length > 0) saveToolsCache(tools);
+  return mergeLocalTools(tools);
+}
+
+/**
+ * Merge locally-scanned tools ahead of (deduplicating by slug) the given list.
+ * Local tools always take priority so dev workflows see the freshest source.
+ */
+function mergeLocalTools(remoteTools) {
+  const local = scanLocalTools();
+  const localSlugs = new Set(local.map((t) => t.slug));
+  const deduped = remoteTools.filter((t) => t && !localSlugs.has(t.slug));
+  return [...local, ...deduped];
+}
+
+// ─── Single tool source (for --local execution) ──────────────────────────────
+
+/**
+ * Resolve a single tool's { manifest, coreLogicSource }.
+ *
+ *   1. Local filesystem → 2. per-tool cache → 3. API → 4. Supabase
+ */
+export async function fetchToolSource(slug) {
+  ensureCacheDir();
+  const cacheFile = path.join(TOOLS_CACHE_DIR, `${slug}.json`);
+
+  // 1. Local filesystem
+  const localPath = findLocalTool(slug);
+  if (localPath) {
+    const source = fs.readFileSync(localPath, "utf-8");
+    const manifest = extractManifest(source);
+    if (manifest) {
+      // Refresh cache from local source
+      fs.writeFileSync(cacheFile, JSON.stringify({ manifest, coreLogicSource: source, cachedAt: new Date().toISOString() }), "utf-8");
+      return { manifest, coreLogicSource: source, source: "local" };
+    }
+  }
+
+  // 2. Per-tool cache (.cache/tools/<slug>.json)
+  if (fs.existsSync(cacheFile)) {
+    try {
+      const cached = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
+      if (cached.manifest && cached.coreLogicSource) {
+        return { manifest: cached.manifest, coreLogicSource: cached.coreLogicSource, source: "cache" };
+      }
+    } catch {
+      /* corrupt cache — ignore */
+    }
+  }
+
+  // 3. Live API
+  try {
+    const res = await fetch(`${API_BASE}/api/run/${slug}`);
+    if (res.ok) {
+      const data = await res.json();
+      const manifest = data.data?.manifest || data.manifest || data;
+      let coreLogicSource;
+      const sourceRes = await fetch(`${API_BASE}/api/run/${slug}?source=true`);
+      if (sourceRes.ok) {
+        const sourceData = await sourceRes.json();
+        coreLogicSource = sourceData.data?.v2_source;
+      }
+      if (manifest) {
+        fs.writeFileSync(cacheFile, JSON.stringify({ manifest, coreLogicSource: coreLogicSource || "", cachedAt: new Date().toISOString() }), "utf-8");
+        return { manifest, coreLogicSource: coreLogicSource || "", source: "api" };
+      }
+    }
+  } catch {
+    /* API unreachable */
+  }
+
+  // 4. Supabase fallback
+  const toolInfo = await fetchToolFromSupabase(slug);
+  if (toolInfo) {
+    fs.writeFileSync(cacheFile, JSON.stringify({ manifest: toolInfo.manifest, coreLogicSource: toolInfo.coreLogicSource, cachedAt: new Date().toISOString() }), "utf-8");
+    return { manifest: toolInfo.manifest, coreLogicSource: toolInfo.coreLogicSource, source: "supabase" };
+  }
+
+  return null;
+}
+
+/**
+ * Fetch a single tool's v2_source from Supabase (fallback).
+ * Returns { manifest, coreLogicSource } or null.
+ */
+export async function fetchToolFromSupabase(slug) {
+  const headers = supabaseHeaders();
+  const supabaseUrl = getSupabaseUrl();
+  try {
+    // Try builtin tools first
+    const toolRes = await fetch(
+      `${supabaseUrl}/rest/v1/tools?slug=eq.${slug}&select=id&published=eq.true`,
+      { headers }
+    );
+    let tools = await toolRes.json();
+    let toolId = tools?.[0]?.id;
+    let toolType = "builtin";
+
+    // Fall back to community tools
+    if (!toolId) {
+      const comRes = await fetch(
+        `${supabaseUrl}/rest/v1/community_tools?slug=eq.${slug}&select=id&status=eq.published`,
+        { headers }
+      );
+      const comTools = await comRes.json();
+      toolId = comTools?.[0]?.id;
+      toolType = "community";
+    }
+
+    if (!toolId) return null;
+
+    const versionRes = await fetch(
+      `${supabaseUrl}/rest/v1/tool_versions?tool_id=eq.${toolId}&tool_type=eq.${toolType}&status=eq.published&select=v2_source&order=created_at.desc&limit=1`,
+      { headers }
+    );
+    const versions = await versionRes.json();
+    const v2Source = versions?.[0]?.v2_source;
+    if (!v2Source) return null;
+
+    const manifest = extractManifest(v2Source);
+    return { manifest, coreLogicSource: v2Source };
+  } catch {
+    return null;
+  }
+}
+
+// ─── Manifest extraction ────────────────────────────────────────────────────
+
+/**
+ * Extract a MANIFEST object from v2 source text.
+ * Handles JS object literals (unquoted keys, single quotes) gracefully.
+ */
+export function extractManifest(source) {
+  if (!source) return null;
+  const match = source.match(/export\s+const\s+MANIFEST\s*=\s*({[\s\S]*?});/);
+  if (!match) return null;
+  try {
+    // eslint-disable-next-line no-new-func
+    return new Function("return " + match[1])();
+  } catch {
+    try {
+      return JSON.parse(match[1].replace(/(\w+):/g, '"$1":').replace(/'/g, '"'));
+    } catch {
+      return null;
+    }
+  }
+}
+
+// ─── Local filesystem scanning ─────────────────────────────────────────────
+
+/**
+ * Search the local filesystem for a single tool's v2.js file.
+ * Checks common locations relative to CWD, plus config.toolsDir override.
+ */
+export function findLocalTool(slug) {
+  const cwd = process.cwd();
+  const candidates = LOCAL_TOOL_DIRS.map((d) => path.join(cwd, d, slug, "v2.js"));
+
+  try {
+    const toolsDir = configGet("toolsDir");
+    if (toolsDir) {
+      candidates.unshift(path.join(cwd, toolsDir, slug, "v2.js"));
+    }
+  } catch {}
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // Last resort: search from workspace root parent dirs
+  const rootCandidates = [
+    path.join(cwd, "..", "apps", "main-site", "frontend", "src", "tools", slug, "v2.js"),
+  ];
+  for (const c of rootCandidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+/**
+ * Scan the local filesystem for ALL tool v2.js files.
+ * Returns array of { slug, name, description, short_description, category, runtime, version, icon, type: "local" }.
+ */
+export function scanLocalTools() {
+  const cwd = process.cwd();
+  const searchDirs = LOCAL_TOOL_DIRS.map((d) => path.join(cwd, d));
+  const tools = [];
+
+  for (const dir of searchDirs) {
+    if (!fs.existsSync(dir)) continue;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const v2Path = path.join(dir, entry.name, "v2.js");
+      if (!fs.existsSync(v2Path)) continue;
+      try {
+        const source = fs.readFileSync(v2Path, "utf-8");
+        const manifest = extractManifest(source);
+        if (!manifest) continue;
+        tools.push({
+          slug: manifest.slug || entry.name,
+          name: manifest.name || entry.name,
+          description: manifest.short_description || "",
+          short_description: manifest.short_description || "",
+          category: manifest.category || "uncategorized",
+          runtime: manifest.runtime || "both",
+          version: manifest.version || "1.0.0",
+          icon: manifest.icon || "🔧",
+          type: "local",
+        });
+      } catch {}
+    }
+  }
+  return tools;
+}
+
+// ─── Abbreviation engine ────────────────────────────────────────────────────
+
+/**
+ * Generate unambiguous abbreviations for a list of slugs.
+ *
+ * Strategy:
+ *   - Start with first letter of each hyphen-word (e.g. "ssl-certificate-checker" → "scc")
+ *   - If that collides or is < 2 chars, grow a prefix until unique
+ *
+ * Returns a bidirectional map: { slug → abbr, abbr → slug }
+ */
+export function generateAbbreviations(slugs) {
+  const abbrMap = {};
+  const used = new Set();
+
+  for (const slug of slugs) {
+    const parts = slug.split("-");
+    let abbr = parts.map((p) => p[0]).join("").toLowerCase();
+
+    // If taken or too short, try progressively longer prefixes
+    if (used.has(abbr) || abbr.length < 2) {
+      for (let len = 2; len <= slug.length; len++) {
+        abbr = slug.slice(0, len);
+        if (!used.has(abbr)) break;
+      }
+    }
+
+    used.add(abbr);
+    abbrMap[slug] = abbr;
+    abbrMap[abbr] = slug;
+  }
+
+  return abbrMap;
+}
+
+/**
+ * Resolve a slug or abbreviation to a canonical slug.
+ *
+ *   resolveToolSlug("scc", tools)   → "ssl-certificate-checker"
+ *   resolveToolSlug("ssl-cert...", tools) → itself (already a full slug)
+ */
+export async function resolveToolSlug(slug, toolsRef = null) {
+  if (!slug) return slug;
+  const allTools = toolsRef || (await fetchTools({ offline: true }));
+  if (!allTools || allTools.length === 0) return slug;
+
+  const slugs = allTools.map((t) => t.slug);
+  // Exact match first
+  if (slugs.includes(slug)) return slug;
+
+  const abbrMap = generateAbbreviations(slugs);
+  if (abbrMap[slug] && slugs.includes(abbrMap[slug])) {
+    return abbrMap[slug];
+  }
+  return slug;
+}
+
+// ─── stdin helper ────────────────────────────────────────────────────────────
+
+export function readStdin() {
+  return new Promise((resolve) => {
+    const chunks = [];
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(chunks.join("")));
+    if (process.stdin.isTTY) resolve("");
+  });
+}