filebread-mcp 0.1.0 → 0.2.1

package/cli.js

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+
+const readline = require("readline");
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const API_URL = process.env.FILEBREAD_API_URL || "https://file-bread.fly.dev";
+const command = process.argv[2];
+
+if (!command || command === "help" || command === "--help") {
+  console.log(`
+  filebread - Give AI agents context about your project
+
+  Commands:
+    init      Set up FileBread in the current project (creates .mcp.json)
+    status    Check connection and indexed sources
+    upload    Upload a file to your knowledge base
+
+  Usage:
+    npx filebread init
+    npx filebread status
+    npx filebread upload ./docs/architecture.md
+`);
+  process.exit(0);
+}
+
+// --- HTTP ---
+
+function apiRequest(method, urlPath, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlPath, API_URL);
+    const mod = url.protocol === "https:" ? https : http;
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method,
+      headers: { "Content-Type": "application/json", ...headers },
+    };
+    const req = mod.request(options, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, body: data }); }
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(15000, () => { req.destroy(); reject(new Error("timeout")); });
+    if (body) req.write(typeof body === "string" ? body : JSON.stringify(body));
+    req.end();
+  });
+}
+
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function askHidden(rl, question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    process.stdout.write(question);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    let input = "";
+    const onData = (ch) => {
+      const c = ch.toString();
+      if (c === "\n" || c === "\r") {
+        stdin.removeListener("data", onData);
+        stdin.setRawMode(wasRaw);
+        stdin.pause();
+        process.stdout.write("\n");
+        resolve(input);
+      } else if (c === "\u0003") {
+        process.exit(0);
+      } else if (c === "\u007f") {
+        input = input.slice(0, -1);
+      } else {
+        input += c;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// --- Init ---
+
+async function init() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log("\n  FileBread Setup\n  ───────────────\n");
+
+  // Check if .mcp.json already exists
+  const mcpPath = path.join(process.cwd(), ".mcp.json");
+  if (fs.existsSync(mcpPath)) {
+    const existing = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+    if (existing.mcpServers?.filebread) {
+      console.log("  FileBread is already configured in this project.");
+      console.log("  Run `npx filebread status` to check the connection.\n");
+      rl.close();
+      return;
+    }
+  }
+
+  // Check for saved config
+  const configDir = path.join(process.env.HOME || process.env.USERPROFILE, ".filebread");
+  const configPath = path.join(configDir, "config.json");
+  let apiKey = null;
+
+  if (fs.existsSync(configPath)) {
+    const saved = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (saved.api_key) {
+      console.log(`  Found saved account (${saved.email || "unknown"})`);
+      const reuse = await ask(rl, "  Use this account? (Y/n) ");
+      if (!reuse || reuse.toLowerCase() !== "n") {
+        apiKey = saved.api_key;
+      }
+    }
+  }
+
+  if (!apiKey) {
+    // Register or login
+    const hasAccount = await ask(rl, "  Do you have a FileBread account? (y/N) ");
+
+    let email, password, token;
+
+    if (hasAccount && hasAccount.toLowerCase() === "y") {
+      email = await ask(rl, "  Email: ");
+      rl.close();
+      password = await askHidden(readline.createInterface({ input: process.stdin, output: process.stdout }), "  Password: ");
+      const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+      const res = await apiRequest("POST", "/api/auth/login", { email, password });
+      if (res.status !== 200) {
+        console.log(`\n  Login failed: ${res.body?.error || "unknown error"}`);
+        rl2.close();
+        process.exit(1);
+      }
+      token = res.body.token;
+      console.log("  Logged in!\n");
+      rl.close = () => rl2.close();
+    } else {
+      email = await ask(rl, "  Email: ");
+      rl.close();
+      password = await askHidden(readline.createInterface({ input: process.stdin, output: process.stdout }), "  Password (min 8 chars): ");
+      const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const name = await ask(rl2, "  Your name: ");
+
+      console.log("  Creating account...");
+      const res = await apiRequest("POST", "/api/auth/register", { email, password, name });
+      if (res.status !== 200 && res.status !== 201) {
+        const err = res.body?.details?.email?.[0] || res.body?.error || "unknown error";
+        console.log(`\n  Registration failed: ${err}`);
+        rl2.close();
+        process.exit(1);
+      }
+      token = res.body.token;
+      console.log("  Account created!\n");
+      rl.close = () => rl2.close();
+    }
+
+    // Create API key
+    console.log("  Creating API key...");
+    const keyRes = await apiRequest("POST", "/api/api-keys", { name: `cli-${Date.now()}` }, { Authorization: `Bearer ${token}` });
+    if (keyRes.status !== 200 && keyRes.status !== 201) {
+      console.log(`  Failed to create API key: ${JSON.stringify(keyRes.body)}`);
+      process.exit(1);
+    }
+    apiKey = keyRes.body.api_key.key;
+
+    // Save config globally
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify({ email, api_key: apiKey }, null, 2));
+    fs.chmodSync(configPath, 0o600);
+    console.log(`  API key saved to ~/.filebread/config.json\n`);
+  }
+
+  // Write .mcp.json
+  let mcpConfig = {};
+  if (fs.existsSync(mcpPath)) {
+    mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers.filebread = {
+    command: "npx",
+    args: ["-y", "filebread-mcp"],
+    env: { FILEBREAD_API_KEY: apiKey },
+  };
+  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+
+  // Add .mcp.json to .gitignore if exists
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, "utf8");
+    if (!gitignore.includes(".mcp.json")) {
+      fs.appendFileSync(gitignorePath, "\n.mcp.json\n");
+      console.log("  Added .mcp.json to .gitignore");
+    }
+  }
+
+  console.log("  Created .mcp.json\n");
+  console.log("  Done! Restart Claude Code or Cursor to activate.\n");
+  console.log("  Next steps:");
+  console.log("  - Upload docs: npx filebread upload ./docs/architecture.md");
+  console.log("  - Connect sources: visit https://file-bread.fly.dev");
+  console.log("  - Check status: npx filebread status\n");
+
+  try { rl.close(); } catch {}
+}
+
+// --- Status ---
+
+async function status() {
+  const mcpPath = path.join(process.cwd(), ".mcp.json");
+  if (!fs.existsSync(mcpPath)) {
+    console.log("\n  FileBread is not configured in this project.");
+    console.log("  Run `npx filebread init` to set up.\n");
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+  const apiKey = config.mcpServers?.filebread?.env?.FILEBREAD_API_KEY;
+
+  if (!apiKey) {
+    console.log("\n  No API key found in .mcp.json");
+    process.exit(1);
+  }
+
+  console.log("\n  FileBread Status\n  ────────────────\n");
+
+  // Check API
+  const health = await apiRequest("GET", "/api/health", null);
+  console.log(`  API: ${health.status === 200 ? "connected" : "error"}`);
+
+  // Check files
+  const files = await apiRequest("GET", "/api/files", null, { "X-API-Key": apiKey });
+  const fileList = files.body?.files || [];
+  console.log(`  Sources: ${fileList.length} files indexed`);
+
+  if (fileList.length > 0) {
+    console.log("");
+    for (const f of fileList.slice(0, 10)) {
+      console.log(`    - ${f.original_name} (${f.content_type})`);
+    }
+    if (fileList.length > 10) console.log(`    ... and ${fileList.length - 10} more`);
+  }
+
+  console.log("");
+}
+
+// --- Upload ---
+
+async function upload() {
+  const filePath = process.argv[3];
+  if (!filePath) {
+    console.log("\n  Usage: npx filebread upload <file>\n");
+    console.log("  Examples:");
+    console.log("    npx filebread upload ./docs/architecture.md");
+    console.log("    npx filebread upload ./README.md\n");
+    process.exit(1);
+  }
+
+  const mcpPath = path.join(process.cwd(), ".mcp.json");
+  if (!fs.existsSync(mcpPath)) {
+    console.log("\n  Run `npx filebread init` first.\n");
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+  const apiKey = config.mcpServers?.filebread?.env?.FILEBREAD_API_KEY;
+
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.log(`\n  File not found: ${absPath}\n`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(absPath);
+  const fileName = path.relative(process.cwd(), absPath);
+  const ext = path.extname(absPath).toLowerCase();
+
+  const mimeTypes = {
+    ".md": "text/markdown", ".txt": "text/plain", ".js": "text/plain",
+    ".ts": "text/plain", ".jsx": "text/plain", ".tsx": "text/plain",
+    ".py": "text/plain", ".rb": "text/plain", ".go": "text/plain",
+    ".rs": "text/plain", ".java": "text/plain", ".sol": "text/plain",
+    ".yaml": "text/plain", ".yml": "text/plain", ".toml": "text/plain",
+    ".json": "application/json", ".html": "text/html", ".css": "text/css",
+    ".pdf": "application/pdf", ".ex": "text/plain", ".exs": "text/plain",
+  };
+  const contentType = mimeTypes[ext] || "text/plain";
+
+  // Multipart upload
+  const boundary = `----filebread${Date.now()}`;
+  const header = `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${fileName}"\r\nContent-Type: ${contentType}\r\n\r\n`;
+  const footer = `\r\n--${boundary}--\r\n`;
+  const body = Buffer.concat([Buffer.from(header), content, Buffer.from(footer)]);
+
+  const url = new URL("/api/files", API_URL);
+  const mod = url.protocol === "https:" ? https : http;
+
+  const res = await new Promise((resolve, reject) => {
+    const req = mod.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": `multipart/form-data; boundary=${boundary}`,
+        "X-API-Key": apiKey,
+        "Content-Length": body.length,
+      },
+    }, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, body: data }); }
+      });
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+
+  if (res.status === 201 || res.status === 200) {
+    console.log(`  Uploaded: ${fileName} (indexing...)`);
+  } else {
+    console.log(`  Error: ${JSON.stringify(res.body)}`);
+  }
+}
+
+// --- Run ---
+
+switch (command) {
+  case "init": init().catch((e) => { console.error(`  Error: ${e.message}`); process.exit(1); }); break;
+  case "status": status().catch((e) => { console.error(`  Error: ${e.message}`); process.exit(1); }); break;
+  case "upload": upload().catch((e) => { console.error(`  Error: ${e.message}`); process.exit(1); }); break;
+  default: console.log(`  Unknown command: ${command}. Run 'npx filebread help' for usage.`); process.exit(1);
+}

package/index.js

@@ -1,16 +1,24 @@
 #!/usr/bin/env node
 
+// If called with a subcommand (init, status, upload, help), run the CLI instead
+const subcommand = process.argv[2];
+if (subcommand && ["init", "status", "upload", "help", "--help"].includes(subcommand)) {
+  require("./cli.js");
+  process.exitCode = undefined; // let cli.js handle exit
+} else {
+// MCP server mode starts here
+
 const readline = require("readline");
 const https = require("https");
 const http = require("http");
 
 const API_KEY = process.env.FILEBREAD_API_KEY;
-const API_URL = process.env.FILEBREAD_API_URL || "https://filebread.com";
+const API_URL = process.env.FILEBREAD_API_URL || "https://file-bread.fly.dev";
 
 if (!API_KEY) {
   process.stderr.write(
     "[filebread-mcp] Error: FILEBREAD_API_KEY is required.\n" +
-      "Get your API key at https://filebread.com/settings/api-keys\n"
+      "Run `npx filebread-mcp init` to set up.\n"
   );
   process.exit(1);
 }
@@ -272,3 +280,5 @@ rl.on("line", (line) => {
 });
 
 rl.on("close", () => process.exit(0));
+
+} // end of MCP server mode

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "filebread-mcp",
-  "version": "0.1.0",
-  "description": "MCP server for FileBread - give AI agents context about your project",
+  "version": "0.2.1",
+  "description": "Give AI agents context about your project. One command setup.",
   "bin": {
-    "filebread-mcp": "./index.js"
+    "filebread-mcp": "./index.js",
+    "filebread": "./cli.js"
   },
-  "keywords": ["mcp", "context", "ai", "claude", "cursor", "rag"],
+  "keywords": ["mcp", "context", "ai", "claude", "cursor", "rag", "developer-tools"],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,5 +15,5 @@
   "engines": {
     "node": ">=18"
   },
-  "files": ["index.js"]
+  "files": ["index.js", "cli.js"]
 }