@caphub/cli 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# `@caphub/cli`
+
+Root CLI for Caphub capabilities.
+
+## Install
+
+```bash
+npm install -g @caphub/cli
+```
+
+Or run without install:
+
+```bash
+npx @caphub/cli help
+```
+
+## Auth
+
+Store your API key once:
+
+```bash
+caphub auth login --api-key csk_live_...
+```
+
+## Discovery
+
+```bash
+caphub help
+caphub capabilities
+caphub help search
+```
+
+## Run capabilities
+
+```bash
+caphub search '{"queries":["site:github.com awesome ai agents"]}'
+```
+
+```bash
+caphub search-ideas '{"queries":["best robot vacuum"]}'
+```

package/bin/caphub.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf8"));
+const DEFAULT_API_URL = "https://api.caphub.io";
+const CONFIG_DIR = resolve(os.homedir(), ".config", "caphub");
+const CONFIG_PATH = resolve(CONFIG_DIR, "config.json");
+
+const ROOT_HELP = `caphub
+
+purpose: root CLI for Caphub agent capabilities
+auth: CAPHUB_API_KEY env or ${CONFIG_PATH}
+api: ${DEFAULT_API_URL}
+
+commands:
+  help                  explain the platform and command layout
+  help <capability>     show capability-specific help from the API
+  capabilities          list live capabilities with short descriptions
+  auth login            save api key locally for future runs
+  auth whoami           verify the current api key against the API
+  auth logout           remove stored api key from local config
+  <capability> <json>   run a capability directly, e.g. search or search-ideas
+
+examples:
+  caphub capabilities
+  caphub auth login --api-key csk_live_...
+  caphub help search
+  caphub search '{"queries":["site:github.com awesome ai agents"]}'
+`;
+
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+function getApiUrl() {
+  const config = readConfig();
+  return (
+    process.env.CAPHUB_API_URL ||
+    config.api_url ||
+    DEFAULT_API_URL
+  ).replace(/\/+$/, "");
+}
+
+function getApiKey() {
+  const config = readConfig();
+  return (
+    process.env.CAPHUB_API_KEY ||
+    config.api_key ||
+    ""
+  ).trim();
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function readStdin() {
+  return new Promise((resolveInput) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => (data += chunk));
+    process.stdin.on("end", () => resolveInput(data));
+  });
+}
+
+async function fetchJson(url, { method = "GET", body, apiKey = "" } = {}) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["X-API-Key"] = apiKey;
+
+  const resp = await fetch(url, {
+    method,
+    headers,
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+
+  const text = await resp.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(`non-JSON response from ${url} (HTTP ${resp.status})`);
+  }
+
+  if (!resp.ok) {
+    throw new Error(data?.error || `HTTP ${resp.status}`);
+  }
+
+  return data;
+}
+
+function parseFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1) return "";
+  return args[idx + 1] || "";
+}
+
+function printCapabilities(payload) {
+  const lines = ["caphub capabilities", ""];
+  for (const capability of payload.capabilities || []) {
+    lines.push(`/${capability.capability} - ${capability.purpose}`);
+    if (capability.credits) lines.push(`  credits: ${capability.credits}`);
+    if (capability.limits?.max_queries_per_request) lines.push(`  max queries: ${capability.limits.max_queries_per_request}`);
+    if (capability.endpoint) lines.push(`  endpoint: ${capability.endpoint}`);
+    lines.push("");
+  }
+  process.stdout.write(lines.join("\n"));
+}
+
+function printCapabilityHelp(payload) {
+  const lines = [
+    payload.capability,
+    "",
+    `purpose: ${payload.purpose}`,
+    `endpoint: ${payload.endpoint}`,
+    `method: ${payload.method}`,
+    payload.credits ? `credits: ${payload.credits}` : null,
+    payload.limits?.max_queries_per_request ? `limits: max ${payload.limits.max_queries_per_request} queries per request` : null,
+    `auth: ${payload.auth?.env || "CAPHUB_API_KEY"} or ${CONFIG_PATH}`,
+    "",
+    "input:",
+    JSON.stringify(payload.input_contract, null, 2),
+    "",
+    "output:",
+    JSON.stringify(payload.output_contract, null, 2),
+  ].filter(Boolean);
+  process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+async function commandHelp(args) {
+  const apiUrl = getApiUrl();
+  const capability = args[0];
+  if (!capability) {
+    process.stdout.write(ROOT_HELP);
+    return;
+  }
+
+  const payload = await fetchJson(`${apiUrl}/v1/${capability}/help`);
+  printCapabilityHelp(payload);
+}
+
+async function commandCapabilities(args) {
+  const apiUrl = getApiUrl();
+  const payload = await fetchJson(`${apiUrl}/v1/help`);
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+  printCapabilities(payload);
+}
+
+async function commandAuth(args) {
+  const sub = args[0];
+  const config = readConfig();
+
+  if (sub === "login") {
+    const apiKey = parseFlag(args, "--api-key") || getApiKey();
+    const apiUrl = parseFlag(args, "--api-url") || getApiUrl();
+    if (!apiKey) fail("Error: auth login requires --api-key or CAPHUB_API_KEY.");
+    writeConfig({
+      ...config,
+      api_key: apiKey,
+      api_url: apiUrl,
+    });
+    process.stdout.write(`${JSON.stringify({ ok: true, config_path: CONFIG_PATH, api_url: apiUrl }, null, 2)}\n`);
+    return;
+  }
+
+  if (sub === "whoami") {
+    const apiKey = getApiKey();
+    if (!apiKey) fail(`Error: no api key configured. Use 'caphub auth login --api-key ...' or set ${CONFIG_PATH}.`);
+    const payload = await fetchJson(`${getApiUrl()}/v1/me`, { apiKey });
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  if (sub === "logout") {
+    const next = { ...config };
+    delete next.api_key;
+    writeConfig(next);
+    process.stdout.write(`${JSON.stringify({ ok: true, config_path: CONFIG_PATH }, null, 2)}\n`);
+    return;
+  }
+
+  fail("Error: auth commands are: login, whoami, logout.");
+}
+
+async function commandCapability(capability, args) {
+  const apiKey = getApiKey();
+  if (!apiKey) fail(`Error: CAPHUB_API_KEY is required, or set api_key in ${CONFIG_PATH}.`);
+
+  if (args[0] === "--help" || args[0] === "help") {
+    await commandHelp([capability]);
+    return;
+  }
+
+  const arg = args[0];
+  const rawInput = arg ?? (process.stdin.isTTY ? "" : await readStdin());
+  if (!rawInput.trim()) {
+    fail(`Error: input JSON is required. Run 'caphub help ${capability}' for the contract.`);
+  }
+
+  let body;
+  try {
+    body = JSON.parse(rawInput);
+  } catch {
+    fail("Error: input must be valid JSON.");
+  }
+
+  if (!("function" in body)) body.function = capability;
+
+  const payload = await fetchJson(`${getApiUrl()}/v1/${capability}`, {
+    method: "POST",
+    apiKey,
+    body,
+  });
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
+    await commandHelp(args.slice(1));
+    return;
+  }
+
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    process.stdout.write(`${pkg.version}\n`);
+    return;
+  }
+
+  if (cmd === "capabilities") {
+    await commandCapabilities(args.slice(1));
+    return;
+  }
+
+  if (cmd === "auth") {
+    await commandAuth(args.slice(1));
+    return;
+  }
+
+  await commandCapability(cmd, args.slice(1));
+}
+
+await main().catch((error) => fail(`Error: ${error.message}`));

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@caphub/cli",
+  "version": "0.1.0",
+  "description": "Root CLI for Caphub agent capabilities",
+  "type": "module",
+  "bin": {
+    "caphub": "bin/caphub.js"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "agents",
+    "cli",
+    "caphub",
+    "search",
+    "automation"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  }
+}