@meshxdata/fops 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshxdata/fops",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "CLI to install and manage Foundation data mesh platforms",
   "keywords": [
     "foundation",

package/src/commands/index.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import https from "node:https";
 import chalk from "chalk";
 import { Command } from "commander";
 import { PKG } from "../config.js";
@@ -385,4 +386,118 @@ export function registerCommands(program, registry) {
       setPluginEnabled(id, false);
       console.log(chalk.yellow(`  ○ Disabled plugin "${id}". Restart fops to apply.`));
     });
+
+  // ── Plugin marketplace ──────────────────────────────
+  const marketplaceCmd = pluginCmd
+    .command("marketplace")
+    .description("Browse and install plugins from GitHub");
+
+  marketplaceCmd
+    .command("add <repo>")
+    .description("Install a plugin from GitHub (owner/repo)")
+    .action(async (repo) => {
+      const parts = repo.split("/");
+      if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        console.error(chalk.red('  Usage: fops plugin marketplace add <owner/repo>'));
+        process.exit(1);
+      }
+      const [owner, repoName] = parts;
+
+      // Download tarball from GitHub
+      const tarballUrl = `https://api.github.com/repos/${owner}/${repoName}/tarball/main`;
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fops-marketplace-"));
+      const tarPath = path.join(tmpDir, "plugin.tar.gz");
+
+      console.log(chalk.blue(`  Downloading ${owner}/${repoName}...`));
+
+      try {
+        await new Promise((resolve, reject) => {
+          const follow = (url) => {
+            https.get(url, { headers: { "User-Agent": "fops-cli", Accept: "application/vnd.github+json" } }, (res) => {
+              if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                follow(res.headers.location);
+                return;
+              }
+              if (res.statusCode !== 200) {
+                reject(new Error(`GitHub returned ${res.statusCode}. Check that ${owner}/${repoName} exists and is public.`));
+                res.resume();
+                return;
+              }
+              const ws = fs.createWriteStream(tarPath);
+              res.pipe(ws);
+              ws.on("finish", resolve);
+              ws.on("error", reject);
+            }).on("error", reject);
+          };
+          follow(tarballUrl);
+        });
+      } catch (err) {
+        console.error(chalk.red(`  Download failed: ${err.message}`));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+
+      // Extract tarball
+      const extractDir = path.join(tmpDir, "extracted");
+      fs.mkdirSync(extractDir, { recursive: true });
+      try {
+        await execa("tar", ["xzf", tarPath, "-C", extractDir]);
+      } catch (err) {
+        console.error(chalk.red(`  Failed to extract archive: ${err.message}`));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+
+      // GitHub tarballs extract into a single directory like owner-repo-sha/
+      const extracted = fs.readdirSync(extractDir);
+      if (extracted.length === 0) {
+        console.error(chalk.red("  Archive was empty."));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+      const pluginSrc = path.join(extractDir, extracted[0]);
+
+      // Validate manifest
+      const manifestPath = path.join(pluginSrc, "fops.plugin.json");
+      if (!fs.existsSync(manifestPath)) {
+        console.error(chalk.red(`  No fops.plugin.json found in ${owner}/${repoName}. Not a valid fops plugin.`));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+
+      let manifest;
+      try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+      } catch {
+        console.error(chalk.red("  Invalid fops.plugin.json"));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+
+      if (!manifest.id) {
+        console.error(chalk.red('  fops.plugin.json missing required "id" field.'));
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        process.exit(1);
+      }
+
+      // Copy to ~/.fops/plugins/<id>/
+      const dest = path.join(os.homedir(), ".fops", "plugins", manifest.id);
+      fs.mkdirSync(dest, { recursive: true });
+
+      const entries = fs.readdirSync(pluginSrc, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcFile = path.join(pluginSrc, entry.name);
+        const destFile = path.join(dest, entry.name);
+        if (entry.isFile()) {
+          fs.copyFileSync(srcFile, destFile);
+        } else if (entry.isDirectory()) {
+          fs.cpSync(srcFile, destFile, { recursive: true });
+        }
+      }
+
+      // Cleanup temp dir
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+
+      console.log(chalk.green(`  ✓ Installed plugin "${manifest.id}" from ${owner}/${repoName} to ${dest}`));
+    });
 }

package/src/doctor.js

@@ -655,6 +655,10 @@ export async function runDoctor(opts = {}, registry = null) {
         const ERROR_RE = /\b(ERROR|FATAL|PANIC|CRITICAL)\b/;
         const CRASH_RE = /\b(OOM|OutOfMemory|out of memory|segmentation fault|segfault)\b/i;
         const CONN_RE = /\b(ECONNREFUSED|ETIMEDOUT|connection refused)\b/i;
+        // Telemetry/analytics hosts whose failures are harmless noise
+        const TELEMETRY_RE = /heapanalytics\.com|segment\.io|sentry\.io|amplitude\.com|mixpanel\.com|telemetry/i;
+        // Harmless startup noise — idempotent init scripts & transient Kafka topic races
+        const BENIGN_RE = /already exists|UNKNOWN_TOPIC_OR_PART/;
 
         for (const line of logOut.split("\n")) {
           const sep = line.indexOf(" | ");
@@ -662,6 +666,9 @@ export async function runDoctor(opts = {}, registry = null) {
           const service = line.slice(0, sep).trim();
           const msg = line.slice(sep + 3);
 
+          if (TELEMETRY_RE.test(msg)) continue;
+          if (BENIGN_RE.test(msg)) continue;
+
           let level = null;
           if (CRASH_RE.test(msg)) level = "crash";
           else if (ERROR_RE.test(msg)) level = "error";

package/src/plugins/bundled/coda/auth.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { execSync } from "node:child_process";
+
+const CREDENTIALS_PATH = path.join(os.homedir(), ".fops", "plugins", "coda", ".credentials.json");
+const CODA_ACCOUNT_URL = "https://coda.io/account";
+
+/**
+ * Prompt for a single line of input from the terminal.
+ */
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Load saved credentials from disk.
+ */
+export function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_PATH)) return null;
+    const raw = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf8"));
+    if (!raw.access_token) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save credentials to disk (mode 0o600).
+ */
+function saveCredentials(creds) {
+  const dir = path.dirname(CREDENTIALS_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2) + "\n", { mode: 0o600 });
+}
+
+/**
+ * Open a URL in the user's default browser.
+ */
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try { execSync(`${cmd} '${url}'`, { stdio: "ignore" }); } catch {}
+}
+
+/**
+ * Run the Coda login flow — prompt user for an API token.
+ * Returns true on success, false on failure.
+ */
+export async function runCodaLogin() {
+  console.log("\n  Coda API Token Setup");
+  console.log("  ────────────────────");
+  console.log(`  1. Go to ${CODA_ACCOUNT_URL}`);
+  console.log("  2. Scroll to \"API Settings\"");
+  console.log("  3. Click \"Generate API token\" and copy it\n");
+
+  openBrowser(CODA_ACCOUNT_URL);
+
+  const token = await ask("  API token: ");
+  if (!token) {
+    console.log("\n  Aborted.\n");
+    return false;
+  }
+
+  saveCredentials({ access_token: token });
+
+  console.log("\n  Saved to ~/.fops/plugins/coda/.credentials.json\n");
+  return true;
+}

package/src/plugins/bundled/coda/client.js

@@ -0,0 +1,187 @@
+import https from "node:https";
+import { URL, URLSearchParams } from "node:url";
+
+const BASE_URL = "https://coda.io/apis/v1";
+
+/**
+ * Simple sliding-window rate limiter.
+ * Tracks timestamps of recent requests and delays when the window is full.
+ */
+class RateLimiter {
+  constructor(maxRequests, windowMs) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.timestamps = [];
+  }
+
+  async wait() {
+    const now = Date.now();
+    this.timestamps = this.timestamps.filter((t) => now - t < this.windowMs);
+
+    if (this.timestamps.length >= this.maxRequests) {
+      const oldest = this.timestamps[0];
+      const delay = this.windowMs - (now - oldest) + 50; // 50ms buffer
+      await new Promise((r) => setTimeout(r, delay));
+    }
+
+    this.timestamps.push(Date.now());
+  }
+}
+
+// Conservative limits under Coda's hard caps (100 reads/6s, 4 doc listings/6s)
+const readLimiter = new RateLimiter(90, 6000);
+const docListLimiter = new RateLimiter(3, 6000);
+
+/**
+ * Make an HTTPS request to the Coda API.
+ */
+function request(method, path, token, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, BASE_URL + "/");
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+    };
+
+    if (body) {
+      const encoded = JSON.stringify(body);
+      options.headers["Content-Length"] = Buffer.byteLength(encoded);
+    }
+
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => { data += chunk; });
+      res.on("end", () => {
+        if (res.statusCode === 401 || res.statusCode === 403) {
+          reject(new Error(`Coda auth error (${res.statusCode}). Run: fops coda login`));
+          return;
+        }
+        if (res.statusCode === 429) {
+          reject(new Error("Coda rate limit exceeded. Wait a moment and retry."));
+          return;
+        }
+        if (res.statusCode >= 400) {
+          let msg = `Coda API error ${res.statusCode}`;
+          try { msg = JSON.parse(data).message || msg; } catch {}
+          reject(new Error(msg));
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error(`Invalid JSON from Coda API: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on("error", reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+/**
+ * Coda API client.
+ */
+export class CodaClient {
+  constructor(token) {
+    this.token = token;
+  }
+
+  /** GET /whoami — verify token and get user info */
+  async whoami() {
+    await readLimiter.wait();
+    return request("GET", `${BASE_URL}/whoami`, this.token);
+  }
+
+  /** GET /docs — list or search docs */
+  async listDocs(query) {
+    await docListLimiter.wait();
+    let url = `${BASE_URL}/docs`;
+    if (query) url += `?query=${encodeURIComponent(query)}`;
+    return request("GET", url, this.token);
+  }
+
+  /** GET /docs/{docId}/pages — list pages in a doc */
+  async listPages(docId) {
+    await readLimiter.wait();
+    return request("GET", `${BASE_URL}/docs/${docId}/pages`, this.token);
+  }
+
+  /**
+   * Export a page as markdown (or html).
+   * POST /docs/{docId}/pages/{pageId}/export → poll until ready → return content.
+   */
+  async exportPage(docId, pageId, format = "markdown") {
+    await readLimiter.wait();
+    const exportReq = await request(
+      "POST",
+      `${BASE_URL}/docs/${docId}/pages/${pageId}/export`,
+      this.token,
+      { outputFormat: format },
+    );
+
+    const requestId = exportReq.id;
+    const deadline = Date.now() + 30_000;
+
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 1000));
+      await readLimiter.wait();
+
+      const status = await request(
+        "GET",
+        `${BASE_URL}/docs/${docId}/pages/${pageId}/export/${requestId}`,
+        this.token,
+      );
+
+      if (status.status === "complete") {
+        return status.downloadLink
+          ? await this._fetchDownload(status.downloadLink)
+          : status;
+      }
+
+      if (status.status === "failed") {
+        throw new Error(`Page export failed: ${status.error || "unknown"}`);
+      }
+    }
+
+    throw new Error("Page export timed out after 30s");
+  }
+
+  /** GET /docs/{docId}/tables — list tables */
+  async listTables(docId) {
+    await readLimiter.wait();
+    return request("GET", `${BASE_URL}/docs/${docId}/tables`, this.token);
+  }
+
+  /** GET /docs/{docId}/tables/{tableId}/rows — list/query rows */
+  async listRows(docId, tableId, query) {
+    await readLimiter.wait();
+    let url = `${BASE_URL}/docs/${docId}/tables/${tableId}/rows`;
+    if (query) url += `?query=${encodeURIComponent(query)}`;
+    return request("GET", url, this.token);
+  }
+
+  /** Fetch raw content from a download link (returned by export). */
+  _fetchDownload(url) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      https.get(parsed, (res) => {
+        // Follow redirects
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          this._fetchDownload(res.headers.location).then(resolve, reject);
+          return;
+        }
+        let data = "";
+        res.on("data", (chunk) => { data += chunk; });
+        res.on("end", () => resolve(data));
+      }).on("error", reject);
+    });
+  }
+}

package/src/plugins/bundled/coda/fops.plugin.json

@@ -0,0 +1,7 @@
+{
+  "id": "coda",
+  "name": "Coda Knowledge Base",
+  "version": "0.1.0",
+  "description": "Interactive Coda knowledge base for the fops agent",
+  "skills": ["skills/coda"]
+}