@meshxdata/fops 0.0.1 → 0.0.4

package/src/doctor.js

@@ -22,7 +22,7 @@ const KEY_PORTS = {
 
 function header(title) {
   console.log(chalk.bold.cyan(`\n  ${title}`));
-  console.log(chalk.gray("  " + "─".repeat(40)));
+  console.log(chalk.dim("  " + "─".repeat(40)));
 }
 
 async function checkPort(port) {
@@ -100,15 +100,15 @@ export async function runDoctor(opts = {}, registry = null) {
   const fixes = []; // collect fix actions to run at the end
 
   const ok = (name, detail) => {
-    console.log(chalk.green("  ✓ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+    console.log(chalk.green("  ✓ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     passed++;
   };
   const warn = (name, detail) => {
-    console.log(chalk.yellow("  ⚠ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+    console.log(chalk.yellow("  ⚠ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     warned++;
   };
   const fail = (name, detail, fixFn) => {
-    console.log(chalk.red("  ✗ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+    console.log(chalk.red("  ✗ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     failed++;
     if (fixFn) fixes.push({ name, fn: fixFn });
   };
@@ -116,6 +116,29 @@ export async function runDoctor(opts = {}, registry = null) {
   // ── Prerequisites ──────────────────────────────────
   header("Prerequisites");
 
+  // winget (Windows only — needed to install other tools)
+  let hasWinget = false;
+  if (process.platform === "win32") {
+    const wingetVer = await cmdVersion("winget");
+    if (wingetVer) {
+      ok("winget available", wingetVer);
+      hasWinget = true;
+    } else {
+      fail("winget not found", "needed to install Docker", async () => {
+        console.log(chalk.cyan("  ▶ Installing winget via Add-AppxPackage…"));
+        await execa("powershell", ["-Command", [
+          "$url = (Invoke-RestMethod 'https://api.github.com/repos/microsoft/winget-cli/releases/latest').assets",
+          "| Where-Object { $_.name -match '.msixbundle$' } | Select-Object -First 1 -ExpandProperty browser_download_url;",
+          "$tmp = Join-Path $env:TEMP 'winget.msixbundle';",
+          "Invoke-WebRequest -Uri $url -OutFile $tmp;",
+          "Add-AppxPackage -Path $tmp;",
+          "Remove-Item $tmp",
+        ].join(" ")], { stdio: "inherit", timeout: 120_000 });
+        hasWinget = true;
+      });
+    }
+  }
+
   // Docker
   const dockerVer = await cmdVersion("docker");
   if (dockerVer) {
@@ -124,12 +147,91 @@ export async function runDoctor(opts = {}, registry = null) {
       await execa("docker", ["info"], { timeout: 5000 });
       ok("Docker running", dockerVer);
     } catch {
-      fail("Docker daemon not running", "start Docker Desktop or dockerd");
+      fail("Docker daemon not running", "start Docker Desktop or dockerd", async () => {
+        if (process.platform === "darwin") {
+          console.log(chalk.cyan("  ▶ open -a Docker"));
+          await execa("open", ["-a", "Docker"], { timeout: 10000 });
+        } else if (process.platform === "win32") {
+          console.log(chalk.cyan('  ▶ start "" "Docker Desktop"'));
+          await execa("cmd", ["/c", "start", "", "Docker Desktop"], { timeout: 10000 });
+        } else {
+          console.log(chalk.cyan("  ▶ sudo systemctl start docker"));
+          await execa("sudo", ["systemctl", "start", "docker"], { stdio: "inherit", timeout: 30000 });
+          return;
+        }
+        // macOS / Windows: wait for daemon to become ready
+        console.log(chalk.dim("  Waiting for Docker daemon to start…"));
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 2000));
+          try {
+            await execa("docker", ["info"], { timeout: 5000 });
+            return;
+          } catch {}
+        }
+        throw new Error("Docker daemon did not start within 60 s");
+      });
     }
   } else {
-    fail("Docker not found", "install from docker.com");
+    fail("Docker not found", "install from docker.com", async () => {
+      if (process.platform === "darwin") {
+        let hasBrew = false;
+        try { await execa("brew", ["--version"]); hasBrew = true; } catch {}
+        if (!hasBrew) {
+          console.log(chalk.cyan("  ▶ Installing Homebrew…"));
+          await execa("bash", ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'], {
+            stdio: "inherit", timeout: 300_000,
+          });
+          // Add brew to PATH for Apple Silicon
+          const brewPaths = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"];
+          for (const bp of brewPaths) {
+            if (fs.existsSync(bp)) {
+              const { stdout } = await execa(bp, ["shellenv"], { timeout: 5000 });
+              for (const line of stdout.split("\n")) {
+                const m = line.match(/export\s+PATH="([^"]+)"/);
+                if (m) process.env.PATH = m[1] + ":" + process.env.PATH;
+              }
+              break;
+            }
+          }
+          hasBrew = true;
+        }
+        console.log(chalk.cyan("  ▶ brew install --cask docker"));
+        await execa("brew", ["install", "--cask", "docker"], { stdio: "inherit", timeout: 300_000 });
+        console.log(chalk.cyan("  ▶ open -a Docker"));
+        await execa("open", ["-a", "Docker"], { timeout: 10000 });
+      } else if (process.platform === "win32") {
+        if (!hasWinget) throw new Error("winget is required to install Docker — fix winget first");
+        console.log(chalk.cyan("  ▶ winget install Docker.DockerDesktop"));
+        await execa("winget", ["install", "Docker.DockerDesktop", "--accept-source-agreements", "--accept-package-agreements"], {
+          stdio: "inherit", timeout: 300_000,
+        });
+        console.log(chalk.cyan('  ▶ start "" "Docker Desktop"'));
+        await execa("cmd", ["/c", "start", "", "Docker Desktop"], { timeout: 10000 });
+      } else {
+        console.log(chalk.cyan("  ▶ curl -fsSL https://get.docker.com | sudo sh"));
+        await execa("sh", ["-c", "curl -fsSL https://get.docker.com | sudo sh"], {
+          stdio: "inherit", timeout: 300_000,
+        });
+        return;
+      }
+      // macOS / Windows: wait for daemon after install
+      console.log(chalk.dim("  Waiting for Docker daemon to start…"));
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 2000));
+        try {
+          await execa("docker", ["info"], { timeout: 5000 });
+          return;
+        } catch {}
+      }
+      throw new Error("Docker daemon did not start within 60 s");
+    });
   }
 
+  // Docker Compose (bundled with Docker Desktop, but verify)
+  const composeVer = await cmdVersion("docker", ["compose", "version"]);
+  if (composeVer) ok("Docker Compose", composeVer);
+  else fail("Docker Compose not found", "included with Docker Desktop — restart Docker or install the compose plugin");
+
   // Git
   const gitVer = await cmdVersion("git");
   if (gitVer) ok("Git available", gitVer);
@@ -141,6 +243,11 @@ export async function runDoctor(opts = {}, registry = null) {
   if (nodeMajor >= 18) ok(`Node.js v${nodeVer}`, ">=18 required");
   else fail(`Node.js v${nodeVer}`, "upgrade to >=18");
 
+  // Claude CLI (bundled as a dependency)
+  const claudeVer = await cmdVersion("claude");
+  if (claudeVer) ok("Claude CLI", claudeVer);
+  else fail("Claude CLI not found", "run: npm install (included as a dependency)");
+
   // AWS CLI (optional)
   const awsVer = await cmdVersion("aws");
   if (awsVer) ok("AWS CLI", awsVer);
@@ -316,21 +423,42 @@ export async function runDoctor(opts = {}, registry = null) {
 
     // Host disk available
     try {
-      const { stdout: dfHost } = await execa("df", ["-h", "/"], {
-        timeout: 5000, reject: false,
-      });
-      if (dfHost) {
-        const lines = dfHost.trim().split("\n");
-        if (lines.length >= 2) {
-          const cols = lines[lines.length - 1].split(/\s+/);
-          const size = cols[1];
-          const avail = cols[3];
-          const pct = parseInt(cols[4], 10);
-          if (pct >= 90) fail(`Host disk: ${avail} free of ${size}`, "critically low — Docker needs room");
-          else if (pct >= 80) warn(`Host disk: ${avail} free of ${size}`, "getting low");
-          else ok(`Host disk: ${avail} free of ${size}`);
+      let size, avail, pct;
+      if (process.platform === "win32") {
+        const { stdout: wmicOut } = await execa("wmic", ["logicaldisk", "where", "DeviceID='C:'", "get", "Size,FreeSpace", "/format:csv"], {
+          timeout: 5000, reject: false,
+        });
+        if (wmicOut) {
+          const parts = wmicOut.trim().split("\n").pop()?.split(",");
+          if (parts?.length >= 3) {
+            const free = parseInt(parts[1], 10);
+            const total = parseInt(parts[2], 10);
+            if (total > 0) {
+              size = `${(total / (1024 ** 3)).toFixed(0)} GB`;
+              avail = `${(free / (1024 ** 3)).toFixed(0)} GB`;
+              pct = Math.round(((total - free) / total) * 100);
+            }
+          }
+        }
+      } else {
+        const { stdout: dfHost } = await execa("df", ["-h", "/"], {
+          timeout: 5000, reject: false,
+        });
+        if (dfHost) {
+          const lines = dfHost.trim().split("\n");
+          if (lines.length >= 2) {
+            const cols = lines[lines.length - 1].split(/\s+/);
+            size = cols[1];
+            avail = cols[3];
+            pct = parseInt(cols[4], 10);
+          }
         }
       }
+      if (size && avail && pct != null) {
+        if (pct >= 90) fail(`Host disk: ${avail} free of ${size}`, "critically low — Docker needs room");
+        else if (pct >= 80) warn(`Host disk: ${avail} free of ${size}`, "getting low");
+        else ok(`Host disk: ${avail} free of ${size}`);
+      }
     } catch {}
 
     // Port conflicts
@@ -386,6 +514,64 @@ export async function runDoctor(opts = {}, registry = null) {
     }
   }
 
+  // ── Logs ──────────────────────────────────────────────
+  if (dir && dockerVer) {
+    header("Logs");
+
+    try {
+      const { stdout: logOut } = await execa("docker", [
+        "compose", "logs", "--tail", "50", "--no-color",
+      ], { cwd: dir, reject: false, timeout: 30000 });
+
+      if (logOut?.trim()) {
+        const serviceIssues = {};
+        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;
+
+        for (const line of logOut.split("\n")) {
+          const sep = line.indexOf(" | ");
+          if (sep === -1) continue;
+          const service = line.slice(0, sep).trim();
+          const msg = line.slice(sep + 3);
+
+          let level = null;
+          if (CRASH_RE.test(msg)) level = "crash";
+          else if (ERROR_RE.test(msg)) level = "error";
+          else if (CONN_RE.test(msg)) level = "conn";
+          else continue;
+
+          if (!serviceIssues[service]) serviceIssues[service] = { errors: 0, crashes: 0, conn: 0, last: "" };
+          const entry = serviceIssues[service];
+          if (level === "crash") entry.crashes++;
+          else if (level === "conn") entry.conn++;
+          else entry.errors++;
+          entry.last = msg.trim();
+        }
+
+        const services = Object.keys(serviceIssues);
+        if (services.length === 0) {
+          ok("No errors in recent logs");
+        } else {
+          for (const svc of services) {
+            const { errors, crashes, conn, last } = serviceIssues[svc];
+            const parts = [];
+            if (crashes) parts.push(`${crashes} crash`);
+            if (errors) parts.push(`${errors} error${errors > 1 ? "s" : ""}`);
+            if (conn) parts.push(`${conn} conn issue${conn > 1 ? "s" : ""}`);
+            const sample = last.length > 120 ? last.slice(0, 120) + "…" : last;
+            if (crashes) fail(svc, `${parts.join(", ")} — ${sample}`);
+            else warn(svc, `${parts.join(", ")} — ${sample}`);
+          }
+        }
+      } else {
+        ok("No log output", "services may not be running");
+      }
+    } catch {
+      warn("Could not fetch logs", "Docker Compose error");
+    }
+  }
+
   // ── Images ──────────────────────────────────────────
   if (dir && dockerVer) {
     header("Images");
@@ -451,12 +637,12 @@ export async function runDoctor(opts = {}, registry = null) {
   }
 
   // ── Summary ────────────────────────────────────────
-  console.log(chalk.gray("\n  " + "─".repeat(40)));
+  console.log(chalk.dim("\n  " + "─".repeat(40)));
   const parts = [];
   if (passed) parts.push(chalk.green(`${passed} passed`));
   if (warned) parts.push(chalk.yellow(`${warned} warnings`));
   if (failed) parts.push(chalk.red(`${failed} failed`));
-  console.log("  " + parts.join(chalk.gray(" · ")));
+  console.log("  " + parts.join(chalk.dim(" · ")));
 
   if (failed > 0 && fixes.length > 0) {
     const shouldFix = opts.fix || await confirm(`\n  Fix ${fixes.length} issue(s) automatically?`, true);
@@ -471,7 +657,7 @@ export async function runDoctor(opts = {}, registry = null) {
           console.log(chalk.red(`  ✗ Fix failed: ${err.message}\n`));
         }
       }
-      console.log(chalk.gray("  Run fops doctor again to verify.\n"));
+      console.log(chalk.dim("  Run fops doctor again to verify.\n"));
     } else {
       console.log("");
       process.exit(1);

package/src/feature-flags.js

@@ -0,0 +1,197 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { execa } from "execa";
+import inquirer from "inquirer";
+
+/**
+ * Canonical feature flags — the complete set known to the platform.
+ * Label is a human-readable short description for the toggle UI.
+ */
+const KNOWN_FLAGS = {
+  MX_FF_STORAGE_EXPLORER_ENABLED: "Storage Explorer",
+  MX_FF_USER_MANAGEMENT_ENABLED: "User Management",
+  MX_FF_SETTINGS_PAGE_ENABLED: "Settings Page",
+  MX_FF_ENCRYPTION_STATUS_DISPLAY: "Encryption Status",
+  MX_FF_USER_PAT_ENABLED: "User PAT (Personal Access Tokens)",
+  MX_FF_SENTRY_ENABLED: "Sentry Error Tracking",
+  MX_FF_EXPLORER_ENABLED: "Data Explorer",
+  MX_FF_NEW_PROFILE_ENABLED: "New Profile Page",
+};
+
+/**
+ * Parse docker-compose.yaml for all MX_FF_* entries.
+ * Returns a map: flagName → { value, services: Set<string>, lines: [{ lineNum, original }] }
+ */
+function parseComposeFlags(composePath) {
+  const content = fs.readFileSync(composePath, "utf8");
+  const lines = content.split("\n");
+  const flags = {};
+
+  // Track which service block we're in
+  let currentService = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Service definition: exactly 2-space indent, ends with colon only
+    const svcMatch = line.match(/^  ([a-z][\w-]+):\s*$/);
+    if (svcMatch) {
+      currentService = svcMatch[1];
+    }
+
+    // Match MX_FF_* in both YAML map and list formats
+    // Map format:  MX_FF_NAME: "value"
+    const mapMatch = line.match(/\b(MX_FF_\w+)\s*:\s*"?(true|false)"?/);
+    // List format:  - MX_FF_NAME=value
+    const listMatch = !mapMatch && line.match(/[-]\s*(MX_FF_\w+)\s*=\s*(true|false)/);
+
+    const match = mapMatch || listMatch;
+    if (match) {
+      const name = match[1];
+      const value = match[2] === "true";
+
+      if (!flags[name]) {
+        flags[name] = { value, services: new Set(), lines: [] };
+      }
+      flags[name].lines.push({ lineNum: i, original: line });
+      if (currentService) flags[name].services.add(currentService);
+      // If any occurrence is true, treat the flag as enabled
+      if (value) flags[name].value = true;
+    }
+  }
+
+  return flags;
+}
+
+/**
+ * Update docker-compose.yaml by flipping flag values on specific lines.
+ */
+function updateComposeFlags(composePath, changes) {
+  const content = fs.readFileSync(composePath, "utf8");
+  const lines = content.split("\n");
+
+  for (const { lineNum, newValue } of changes) {
+    const line = lines[lineNum];
+    lines[lineNum] = line
+      .replace(/(MX_FF_\w+\s*:\s*)"?(true|false)"?/, `$1"${newValue}"`)
+      .replace(/(MX_FF_\w+=)(true|false)/, `$1${newValue}`);
+  }
+
+  fs.writeFileSync(composePath, lines.join("\n"));
+}
+
+/**
+ * Interactive feature flag configuration.
+ * Reads flags from compose, presents toggle UI, applies changes, restarts services.
+ */
+export async function runFeatureFlags(root) {
+  const composePath = path.join(root, "docker-compose.yaml");
+  if (!fs.existsSync(composePath)) {
+    console.log(chalk.red("  No docker-compose.yaml found."));
+    return;
+  }
+
+  console.log(chalk.bold.cyan("\n  Feature Flags\n"));
+
+  // Parse current state from compose
+  const composeFlags = parseComposeFlags(composePath);
+
+  // Build the full flag list: compose flags + canonical flags not yet in compose
+  const allFlags = {};
+  for (const [name, info] of Object.entries(composeFlags)) {
+    allFlags[name] = { ...info, inCompose: true };
+  }
+  for (const name of Object.keys(KNOWN_FLAGS)) {
+    if (!allFlags[name]) {
+      allFlags[name] = { value: false, services: new Set(), lines: [], inCompose: false };
+    }
+  }
+
+  const flagNames = Object.keys(allFlags).sort();
+
+  // Show current state
+  for (const name of flagNames) {
+    const flag = allFlags[name];
+    const label = KNOWN_FLAGS[name] || name;
+    const services = flag.services.size > 0 ? chalk.dim(` (${[...flag.services].join(", ")})`) : "";
+    if (flag.value) {
+      console.log(chalk.green(`  ✓ ${label}`) + services);
+    } else {
+      console.log(chalk.dim(`  · ${label}`) + services);
+    }
+  }
+  console.log("");
+
+  // Checkbox prompt
+  const choices = flagNames.map((name) => ({
+    name: KNOWN_FLAGS[name] || name,
+    value: name,
+    checked: allFlags[name].value,
+  }));
+
+  const { enabled } = await inquirer.prompt([{
+    type: "checkbox",
+    name: "enabled",
+    message: "Toggle feature flags:",
+    choices,
+  }]);
+
+  // Calculate changes
+  const changes = [];
+  const affectedServices = new Set();
+
+  for (const name of flagNames) {
+    const flag = allFlags[name];
+    const newValue = enabled.includes(name);
+
+    if (newValue !== flag.value) {
+      if (flag.inCompose) {
+        for (const line of flag.lines) {
+          changes.push({ lineNum: line.lineNum, newValue: String(newValue) });
+        }
+        for (const svc of flag.services) affectedServices.add(svc);
+      } else if (newValue) {
+        console.log(chalk.yellow(`  ⚠ ${KNOWN_FLAGS[name] || name} not in docker-compose.yaml — add it to service environments to take effect`));
+      }
+    }
+  }
+
+  if (changes.length === 0) {
+    console.log(chalk.dim("\n  No changes.\n"));
+    return;
+  }
+
+  // Apply changes to compose file
+  updateComposeFlags(composePath, changes);
+  console.log(chalk.green(`\n  ✓ Updated ${changes.length} flag value(s) in docker-compose.yaml`));
+
+  if (affectedServices.size === 0) {
+    console.log("");
+    return;
+  }
+
+  // Restart affected services
+  const serviceList = [...affectedServices];
+  console.log(chalk.dim(`  Affected: ${serviceList.join(", ")}`));
+
+  const { restart } = await inquirer.prompt([{
+    type: "confirm",
+    name: "restart",
+    message: `Restart ${serviceList.length} service(s)?`,
+    default: true,
+  }]);
+
+  if (restart) {
+    console.log(chalk.cyan(`\n  ▶ docker compose up -d ${serviceList.join(" ")}\n`));
+    await execa("docker", ["compose", "up", "-d", ...serviceList], {
+      cwd: root,
+      stdio: "inherit",
+      reject: false,
+      timeout: 120_000,
+    });
+    console.log(chalk.green("\n  ✓ Services restarted.\n"));
+  } else {
+    console.log(chalk.dim("\n  Changes saved. Restart manually: docker compose up -d\n"));
+  }
+}

package/src/plugins/api.js

@@ -33,5 +33,28 @@ export function createPluginApi(pluginId, registry) {
     registerHook(event, handler, priority = 0) {
       registry.hooks.push({ pluginId, event, handler, priority });
     },
+
+    registerKnowledgeSource(source) {
+      registry.knowledgeSources.push({
+        pluginId,
+        name: source.name,
+        description: source.description || "",
+        search: source.search,
+      });
+    },
+
+    registerAutoRunPattern(pattern) {
+      registry.autoRunPatterns.push({ pluginId, pattern });
+    },
+
+    registerAgent(agent) {
+      registry.agents.push({
+        pluginId,
+        name: agent.name,
+        description: agent.description || "",
+        systemPrompt: agent.systemPrompt,
+        contextMode: agent.contextMode || "full",
+      });
+    },
   };
 }

package/src/plugins/builtins/stack-api.js

@@ -0,0 +1,36 @@
+import http from "node:http";
+
+/**
+ * Built-in Stack API plugin.
+ * Registers a doctor check (health ping) and auto-run patterns for curl commands.
+ */
+export function register(api) {
+  // Doctor check — ping GET /health on localhost:3090
+  api.registerDoctorCheck({
+    name: "Stack API",
+    fn: async (ok, warn) => {
+      try {
+        const body = await new Promise((resolve, reject) => {
+          const req = http.get("http://localhost:3090/health", { timeout: 3000 }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+              if (res.statusCode === 200) resolve(data);
+              else reject(new Error(`HTTP ${res.statusCode}`));
+            });
+          });
+          req.on("error", reject);
+          req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+        });
+        ok("Stack API", `healthy — ${body.trim().slice(0, 60)}`);
+      } catch {
+        warn("Stack API", "not reachable on localhost:3090");
+      }
+    },
+  });
+
+  // Auto-run: GET curl commands to the stack API execute without confirmation
+  api.registerAutoRunPattern("curl http://localhost:3090/");
+  api.registerAutoRunPattern("curl -s http://localhost:3090/");
+  api.registerAutoRunPattern("curl --silent http://localhost:3090/");
+}

package/src/plugins/index.js

@@ -1,3 +1,4 @@
 export { loadPlugins } from "./loader.js";
 export { runHook } from "./hooks.js";
 export { loadSkills } from "./skills.js";
+export { searchKnowledge } from "./knowledge.js";