@nexusbloom/cli 0.2.11 → 0.3.0

package/src/list.js

@@ -0,0 +1,107 @@
+/**
+ * list.js — `nxb list` command.
+ *
+ * Lists available tools in a paginated, table-style view with icons,
+ * categories, and type badges.  Supports:
+ *
+ *   nxb list                 — interactive pagination (10/page, prev/next)
+ *   nxb list -s ssl          — filter + still paginated
+ *   nxb list --json          — raw JSON
+ *   nxb list --no-interactive— non-interactive single dump
+ */
+
+import chalk from "chalk";
+import { fetchTools, resolveToolSlug, generateAbbreviations } from "./tools.js";
+import { renderHeader, renderTable, paginate, paginateInteractive, typeBadge, categoryBadge, PAGE_SIZE, renderPageInfo } from "./ui.js";
+
+/**
+ * Render a single page of tools as a table.
+ */
+function renderToolsPage(result) {
+  if (result.total === 0) {
+    console.log(chalk.yellow("  No tools found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
+    return;
+  }
+
+  const rows = result.items.map((t, i) => ({
+    "#": chalk.gray(result.startIndex + i + 1),
+    name: `${t.icon || "🔧"}  ${t.name || t.slug}`,
+    slug: chalk.cyan(t.slug || ""),
+    cat: categoryBadge(t.category || "uncategorized"),
+    type: typeBadge(t),
+    tags: t.tags && t.tags.length ? chalk.gray(t.tags.slice(0, 3).join(",")) : "",
+  }));
+
+  const cols = [
+    { key: "#", header: "#", width: 4 },
+    { key: "name", header: "Tool", width: 32 },
+    { key: "slug", header: "Slug", width: 26 },
+    { key: "cat", header: "Category", width: 14, align: "center" },
+    { key: "type", header: "Type", width: 12, align: "center" },
+    { key: "tags", header: "Tags", width: 20 },
+  ];
+
+  renderTable(cols, rows, { headColor: "bold" });
+  console.log();
+  renderPageInfo(result);
+}
+
+/**
+ * The `nxb list` action.
+ */
+export async function listAction(opts = {}) {
+  const { search, json: jsonMode, interactive = true, force = false, offline = false } = opts;
+
+  let tools = await fetchTools({ force, offline });
+  let filtered = tools;
+
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = tools.filter(
+      (t) =>
+        (t.slug || "").includes(q) ||
+        (t.name || "").toLowerCase().includes(q) ||
+        (t.short_description || t.description || "").toLowerCase().includes(q) ||
+        (t.category || "").includes(q) ||
+        (t.tags || []).some((tg) => tg.toLowerCase().includes(q))
+    );
+  }
+
+  // ── JSON mode: dump everything, no pagination ──
+  if (jsonMode) {
+    console.log(JSON.stringify({ tools: filtered }, null, 2));
+    return;
+  }
+
+  // ── Non-interactive: single-page dump ──
+  if (!interactive) {
+    renderHeader("NexusBloom Tools", { subtitle: `${filtered.length} tool${filtered.length === 1 ? "" : "s"} available` });
+    if (filtered.length === 0) return;
+    const result = paginate(filtered, filtered.length, 1);
+    renderToolsPage(result);
+    return;
+  }
+
+  // ── Interactive: paginated with live navigation ──
+  const abbrMap = generateAbbreviations(filtered.map((t) => t.slug));
+  const abbrCount = Object.keys(abbrMap).filter((k) => !(k in filtered.map((t) => t.slug))).length;
+
+  renderHeader("NexusBloom Tools", {
+    subtitle: `${filtered.length} tool${filtered.length === 1 ? "" : "s"} available · page 1 of ${Math.ceil(filtered.length / PAGE_SIZE) || 1}`,
+  });
+
+  await paginateInteractive(
+    filtered,
+    PAGE_SIZE,
+    (result) => {
+      console.clear();
+      renderHeader("NexusBloom Tools", {
+        subtitle: `${result.total} tool${result.total === 1 ? "" : "s"} · page ${chalk.cyan(result.page)} of ${chalk.cyan(result.totalPages)}`,
+      });
+      renderToolsPage(result);
+    },
+    {}
+  );
+}
+
+export default listAction;

package/src/paths.js

@@ -0,0 +1,42 @@
+/**
+ * paths.js — Centralised filesystem paths for the nxb CLI.
+ *
+ * Keeps config + cache locations in one place so every module can share them
+ * without duplicating the XDG / home-directory logic.
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ─── Config (nxb config) ──────────────────────────────────────────────────────
+export const CONFIG_DIR = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+  "nexusbloom"
+);
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+// ─── Tool list cache (offline tool catalogue) ─────────────────────────────────
+// Stored under ~/.cache/nexusbloom/tools.json — a flat snapshot of every tool
+// so `nxb list` / `nxb abbr` work without a network round-trip.
+export const CACHE_DIR = path.resolve(__dirname, "../.cache");
+export const TOOLS_CACHE_DIR = path.join(CACHE_DIR, "tools");
+export const TOOLS_LIST_CACHE_PATH = path.join(CACHE_DIR, "tools-list.json");
+
+// ─── Local tool source cache (for --local execution) ──────────────────────────
+export const TOOL_SOURCE_CACHE_DIR = TOOLS_CACHE_DIR;
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+export function ensureConfigDir() {
+  ensureDir(CONFIG_DIR);
+}
+
+export function ensureCacheDir() {
+  ensureDir(TOOLS_CACHE_DIR);
+}

package/src/run.js

@@ -0,0 +1,380 @@
+/**
+ * run.js — `nxb run` command.
+ *
+ * Two modes:
+ *   1. Direct:  nxb run <slug> [key=value ...] [--input json] [--file path] [--local]
+ *   2. Interactive: nxb run (no slug) → select tool → pick inputs → auto-build & execute
+ *
+ * Imports execution logic from the original monolithic index.js but adds
+ * inquirer-driven field prompting for the interactive path.
+ */
+
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import QRCode from "qrcode";
+
+import {
+  fetchTools,
+  fetchToolSource,
+  resolveToolSlug,
+  configGet,
+  API_BASE,
+  readStdin,
+} from "./tools.js";
+import {
+  renderHeader,
+  renderBox,
+  typeBadge,
+  promptSelect,
+  promptInput,
+  promptConfirm,
+  promptNumber,
+} from "./ui.js";
+
+// ─── Remote execution ────────────────────────────────────────────────────────
+
+export async function runRemote(slug, body, { apiKey, jsonMode, slugResolved }) {
+  const key = apiKey || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
+  if (!key) {
+    if (!jsonMode) console.log(chalk.dim("  No API key — falling back to local execution..."));
+    return runLocal(slug, body, { jsonMode, slugResolved });
+  }
+
+  const spinner = !jsonMode ? ora(chalk.gray(`  Running ${slug}...`))`.start()` : null;
+
+  try {
+    const res = await fetch(`${API_BASE}/api/run/${slug}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok && !res.headers.get("content-type")?.includes("json")) {
+      if (spinner) spinner.succeed(chalk.dim("  API not deployed — falling back to local"));
+      return runLocal(slug, body, { jsonMode, slugResolved });
+    }
+
+    const data = await res.json();
+    if (spinner) {
+      if (data.success) spinner.succeed(chalk.green(`  ${slug} completed`));
+      else spinner.fail(chalk.red(`  ${slug} failed`));
+    }
+
+    if (data.success) {
+      if (data.data && typeof data.data === "object" && data.data.svg) {
+        await renderQRCode(body.data || body.text || JSON.stringify(body), slug);
+      }
+      if (jsonMode) return console.log(JSON.stringify({ success: true, data: data.data }, null, 2));
+      console.log(chalk.green("\n  Result:"));
+      console.log(`  ${JSON.stringify(data.data, null, 2)}`);
+      return;
+    }
+
+    if (jsonMode) return console.log(JSON.stringify({ success: false, error: data.error || "Unknown error" }, null, 2));
+    console.error(chalk.red(`\n  Error: ${data.error || "Unknown error"}`));
+    process.exitCode = 1;
+  } catch (err) {
+    if (spinner) spinner.fail(chalk.dim("  API unreachable — falling back to local"));
+    return runLocal(slug, body, { jsonMode, slugResolved });
+  }
+}
+
+// ─── Local execution ────────────────────────────────────────────────────────
+
+export async function runLocal(slug, input, { jsonMode, slugResolved, source: src } = {}) {
+  const toolInfo = await fetchToolSource(slug);
+  if (!toolInfo) {
+    if (jsonMode) return console.log(JSON.stringify({ error: `Tool "${slug}" not found.` }));
+    console.error(chalk.red(`Tool "${slug}" not found. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API.`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const { manifest, coreLogicSource } = toolInfo;
+  if (!coreLogicSource) {
+    if (jsonMode)
+      return console.log(JSON.stringify({ error: "No v2 source available for local execution." }));
+    console.error(chalk.yellow("No v2 source available for local execution. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!jsonMode) console.log(chalk.dim(`  Using ${slugResolved ? "local" : src || "cached"} tool: ${slug}`));
+
+  // Strip imports/exports, wrap in IIFE that returns coreLogic
+  const cleanSource = coreLogicSource
+    .replace(/^import\s+.*?;?\s*$/gm, "")
+    .replace(/^export\s+/gm, "");
+  const wrappedSource = `(function() {\n${cleanSource}\nreturn coreLogic;\n})()`;
+  const coreLogicFn = new Function("return " + wrappedSource)();
+  const isAsync = /export\s+async\s+function\s+coreLogic/.test(coreLogicSource);
+
+  const schema = manifest.input_schema || {};
+  const required = schema.required || [];
+  const missing = required.filter((k) => input[k] === undefined || input[k] === null);
+  if (missing.length > 0) {
+    if (jsonMode) return console.log(JSON.stringify({ error: `Missing required fields: ${missing.join(", ")}` }));
+    console.error(chalk.red(`Missing required fields: ${missing.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Apply defaults
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (input[key] === undefined && prop.default !== undefined) {
+        input[key] = prop.default;
+      }
+    }
+  }
+
+  const timeoutMs = manifest.timeout_ms || 5000;
+  const spinner = !jsonMode ? ora(chalk.gray(`  Executing ${slug} (local)`)).start() : null;
+  let result;
+
+  try {
+    if (isAsync) {
+      result = await Promise.race([
+        coreLogicFn(input),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs)),
+      ]);
+    } else {
+      result = coreLogicFn(input);
+    }
+    if (spinner) spinner.succeed(chalk.green(`  ${slug} completed`));
+
+    // Fire-and-forget telemetry
+    const apiKey = process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
+    const trackHeaders = { "Content-Type": "application/json" };
+    if (apiKey) trackHeaders["Authorization"] = `Bearer ${apiKey}`;
+    fetch(`${API_BASE}/api/track-run`, { method: "POST", headers: trackHeaders, body: JSON.stringify({ slug, source: "cli" }) }).catch(() => {});
+
+    if (jsonMode) return console.log(JSON.stringify({ success: true, data: result }, null, 2));
+    console.log(chalk.green("\n  Result (local):"));
+    console.log(`  ${JSON.stringify(result, null, 2)}`);
+  } catch (err) {
+    if (spinner) spinner.fail(chalk.red(`  Execution error`));
+    if (jsonMode) return console.log(JSON.stringify({ error: err.message }));
+    console.error(chalk.red(`\n  Local execution error: ${err.message}`));
+    process.exitCode = 1;
+  }
+}
+
+// ─── Input building ─────────────────────────────────────────────────────────
+
+/**
+ * Build the input body from key=value args, --input, --file, and stdin.
+ * Priority: --input > --file > stdin > key=value args.
+ */
+export async function buildInputBody(opts, args) {
+  const { input: inputFlag, file } = opts;
+  let body = {};
+
+  // stdin detection (auto or explicit @-)
+  const isPiped = inputFlag === "@-" || inputFlag === "@stdin" || (!inputFlag && !file && !process.stdin.isTTY);
+  if (isPiped) {
+    try {
+      const stdin = await readStdin();
+      if (stdin && stdin.trim()) body = JSON.parse(stdin);
+    } catch {
+      console.error(chalk.red("Error: Invalid JSON received from stdin"));
+      process.exitCode = 1;
+      return null;
+    }
+  }
+
+  // --input flag (highest priority after stdin)
+  if (inputFlag && inputFlag !== "@-" && inputFlag !== "@stdin") {
+    try {
+      body = JSON.parse(inputFlag);
+    } catch {
+      console.error(chalk.red("Error: --input must be valid JSON"));
+      process.exitCode = 1;
+      return null;
+    }
+  }
+
+  // --file
+  if (file) {
+    try {
+      const fileContent = fs.readFileSync(path.resolve(file), "utf-8");
+      body = { ...JSON.parse(fileContent), ...body };
+    } catch (err) {
+      console.error(chalk.red(`Error reading file: ${err.message}`));
+      process.exitCode = 1;
+      return null;
+    }
+  }
+
+  // key=value args (lowest priority)
+  if (!inputFlag && !file) {
+    (args || []).forEach((arg) => {
+      const [k, ...v] = arg.split("=");
+      body[k] = v.join("=");
+    });
+  }
+
+  return body;
+}
+
+// ─── QR code renderer ────────────────────────────────────────────────────────
+
+async function renderQRCode(data, slug) {
+  try {
+    const qr = await QRCode.toString(data, { type: "terminal", small: true });
+    console.log(chalk.cyan("\n  QR Code:"));
+    console.log(qr);
+    console.log(chalk.dim(`  Data: ${data.slice(0, 80)}${data.length > 80 ? "..." : ""}`));
+  } catch {
+    /* silently skip */
+  }
+}
+
+// ─── Interactive runner ────────────────────────────────────────────────────
+
+/**
+ * `nxb run` with no slug: interactively select a tool and its inputs,
+ * then auto-build & execute the exact command.
+ */
+export async function runInteractive(opts = {}) {
+  const { json: jsonMode } = opts;
+  const tools = await fetchTools({ offline: true });
+
+  if (!tools || tools.length === 0) {
+    console.log(chalk.yellow("  No tools available. Set NEXUSBLOOM_SUPABASE_ANON_KEY or deploy the API."));
+    return;
+  }
+
+  renderHeader("NexusBloom — Interactive Runner", { subtitle: "Select a tool to run" });
+
+  // 1. Select a tool
+  const choices = tools.map((t) => ({
+    name: `${t.icon || "🔧"}  ${t.name || t.slug}  ${typeBadge(t)}`,
+    value: t,
+    description: t.short_description || t.description || "",
+  }));
+
+  const selected = await promptSelect("Choose a tool:", choices, { pageSize: 15 });
+  if (!selected) return;
+
+  const slug = selected.slug;
+  const resolved = await resolveToolSlug(slug, tools);
+
+  // 2. Fetch manifest / schema
+  const toolInfo = await fetchToolSource(resolved);
+  if (!toolInfo?.manifest) {
+    console.log(chalk.yellow(`  No schema available for "${resolved}". Falling back to raw input.`));
+    await runCommand(resolved, {}, { ...opts, jsonMode });
+    return;
+  }
+
+  const { manifest } = toolInfo;
+  const schema = manifest.input_schema || { type: "object", properties: {} };
+
+  renderHeader("Configure Inputs", { subtitle: manifest.short_description || manifest.name });
+
+  // 3. Prompt for each field
+  const body = {};
+  const props = schema.properties || {};
+  const required = schema.required || [];
+
+  for (const [key, prop] of Object.entries(props)) {
+    const req = required.includes(key);
+    const hint = prop.description || "";
+    const suffix = req ? chalk.red(" *required") : chalk.dim(" (optional)");
+    const label = `${key}${suffix}${hint ? chalk.dim(` — ${hint}`) : ""}`;
+
+    const val = await promptField(key, prop);
+    if (val !== undefined) body[key] = val;
+  }
+
+  // Allow extra fields
+  const extra = await promptConfirm("Add a custom field?", { default: false });
+  if (extra) {
+    const k = await promptInput("  Field name:");
+    if (k) {
+      const v = await promptInput(`  Value for "${k}":`);
+      if (v !== undefined) body[k] = v;
+    }
+  }
+
+  // 4. Auto-build the command
+  const inputJson = JSON.stringify(body);
+  const command = `nxb run ${resolved} --input '${inputJson}'`;
+  const isLocal = !process.env.NEXUSBLOOM_API_KEY && !configGet("apiKey") && !configGet("key");
+  const fullCommand = `${command}${isLocal ? " --local" : ""}`;
+
+  renderBox("Generated Command", [
+    chalk.green(fullCommand),
+    "",
+    chalk.dim(`Tool: ${manifest.name} (${resolved})`),
+    chalk.dim(`Input: ${inputJson}`),
+  ], { width: 78 });
+
+  // 5. Confirm & execute
+  const runIt = await promptConfirm("Execute now?", { default: true });
+  if (!runIt) {
+    console.log(chalk.dim("  Command copied to clipboard (if available):"));
+    console.log(chalk.gray(`  ${fullCommand}`));
+    return;
+  }
+
+  // Execute directly via the same path
+  await runCommand(resolved, body, { ...opts, jsonMode, resolved });
+}
+
+/** Prompt for a single schema field based on its type. */
+async function promptField(key, prop) {
+  const { type, enum: enumVals, default: def } = prop;
+
+  // Enum → select
+  if (enumVals && Array.isArray(enumVals) && enumVals.length > 0) {
+    const choices = enumVals.map((v) => ({
+      name: String(v),
+      value: v,
+      ...(v === def && { checked: true }),
+    }));
+    if (def !== undefined) choices.unshift({ name: chalk.gray("(default)"), value: def });
+    return promptSelect(`${key}:`, choices);
+  }
+
+  // Number / integer
+  if (type === "number" || type === "integer") {
+    return promptNumber(`${key}:`, { min: prop.minimum, max: prop.maximum, default: def });
+  }
+
+  // Boolean
+  if (type === "boolean") {
+    return promptConfirm(`${key}:`, { default: def ?? true });
+  }
+
+  // Object / array → JSON string input
+  if (type === "object" || type === "array") {
+    const defaultStr = def !== undefined ? JSON.stringify(def) : [];
+    const raw = await promptInput(`${key}: (JSON)`, { defaultValue: defaultStr });
+    if (!raw) return def;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      console.log(chalk.yellow("  Invalid JSON — using raw string"));
+      return raw;
+    }
+  }
+
+  // Default: string input
+  return promptInput(`${key}:`, { defaultValue: def });
+}
+
+/** Execute a resolved slug+body, choosing local vs remote. */
+async function runCommand(slug, body, opts = {}) {
+  const { json: jsonMode, resolved, local } = opts;
+  const apiKey = opts.key || process.env.NEXUSBLOOM_API_KEY || configGet("apiKey") || configGet("key");
+
+  if (local || !apiKey) {
+    await runLocal(slug, body, { jsonMode, slugResolved: resolved });
+    return;
+  }
+  await runRemote(slug, body, { apiKey, jsonMode, slugResolved: resolved });
+}