@meshxdata/fops 0.0.4 → 0.0.6

package/src/plugins/bundled/fops-plugin-memory/skills/memory/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: memory
+description: Persistent memory across agent sessions
+---
+
+## Agent Memory
+
+You have persistent memory across sessions. Relevant memories are automatically recalled into your context when they match the user's query. You can also save new memories during conversations.
+
+## When to Save Memories
+
+Save a memory when you learn something that would be useful in **future sessions**:
+
+- **Resolved issues**: "postgres init fails if vault isn't started first — start vault before running migrations"
+- **User preferences**: "user prefers to rebuild images rather than pull from ECR"
+- **Stack quirks**: "trino takes 30-45 seconds to become healthy after container starts"
+- **Configuration discoveries**: "frontend needs NEXT_PUBLIC_API_URL set to http://localhost:9001 in .env"
+- **Debugging insights**: "backend OOM usually means too many Kafka consumers — reduce KAFKA_MAX_POLL_RECORDS"
+- **Workflow patterns**: "user runs fops down && fops up to reset state, not just restart"
+
+## How to Save
+
+```bash
+fops memory save "description of what you learned"
+fops memory save "postgres needs vault running first" --tag postgres --tag startup
+```
+
+Tags help with recall but are optional. The text itself is searched.
+
+## When NOT to Save
+
+- Transient state (container is currently down, an image was just pulled)
+- Information already in the stack context (service ports, container health)
+- Generic knowledge (Docker commands, AWS docs)
+- Anything the user explicitly asks you not to remember
+
+## Commands
+
+```bash
+fops memory save "text" [--tag tag1 --tag tag2]   # Save a memory
+fops memory list                                    # List all memories
+fops memory search "query"                          # Search by relevance
+fops memory forget <id>                             # Remove a memory
+fops memory clear                                   # Clear all memories
+fops mem ...                                        # Shorthand alias
+```
+
+## Recall
+
+Memories are automatically recalled via the knowledge system. When the user's message matches stored memories, they appear in your context under "Agent Memory". You don't need to explicitly search — relevant memories are injected per turn.
+
+## Housekeeping
+
+If you notice a recalled memory is outdated or incorrect, suggest removing it:
+
+```bash
+fops memory forget abc123
+```

package/src/plugins/loader.js

@@ -10,6 +10,45 @@ import { loadBuiltinAgents } from "../agent/agents.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Sync bundled plugins from src/plugins/bundled/ to ~/.fops/plugins/.
+ * Installs missing plugins and updates existing ones when the bundled version is newer.
+ */
+function syncBundledPlugins() {
+  const bundledDir = path.join(__dirname, "bundled");
+  if (!fs.existsSync(bundledDir)) return;
+
+  const globalDir = path.join(os.homedir(), ".fops", "plugins");
+  fs.mkdirSync(globalDir, { recursive: true });
+
+  const entries = fs.readdirSync(bundledDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const srcDir = path.join(bundledDir, entry.name);
+    const manifestPath = path.join(srcDir, "fops.plugin.json");
+    if (!fs.existsSync(manifestPath)) continue;
+
+    let manifest;
+    try { manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")); } catch { continue; }
+
+    const destDir = path.join(globalDir, entry.name);
+    const destManifest = path.join(destDir, "fops.plugin.json");
+
+    // Skip if installed version is same or newer
+    if (fs.existsSync(destManifest)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(destManifest, "utf8"));
+        if (existing.version >= manifest.version) continue;
+      } catch {
+        // corrupt manifest — overwrite
+      }
+    }
+
+    // Copy plugin to ~/.fops/plugins/<name>/
+    fs.cpSync(srcDir, destDir, { recursive: true });
+  }
+}
+
 /**
  * Ensure ~/.fops/plugins/node_modules symlinks to the CLI's node_modules.
  * This lets global plugins resolve bare imports (chalk, execa, inquirer, etc.)
@@ -106,6 +145,7 @@ async function loadBuiltinPlugins(registry) {
  * Returns a populated PluginRegistry.
  */
 export async function loadPlugins() {
+  syncBundledPlugins();
   ensurePluginNodeModules();
   const registry = createRegistry();
   loadBuiltinAgents(registry);

package/src/setup/aws.js

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import readline from "node:readline";
 import chalk from "chalk";
 import { execa } from "execa";
 import inquirer from "inquirer";
@@ -138,20 +137,6 @@ export function detectAwsSsoProfiles() {
   return profiles;
 }
 
-/**
- * Simple readline prompt helper.
- */
-function ask(question, defaultVal) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const suffix = defaultVal ? chalk.dim(` (${defaultVal})`) : "";
-  return new Promise((resolve) => {
-    rl.question(`  ${question}${suffix}: `, (answer) => {
-      rl.close();
-      resolve(answer.trim() || defaultVal || "");
-    });
-  });
-}
-
 /**
  * Check if ~/.aws/config has an sso-session block with sso_start_url.
  * If not, prompt user for the values and write them.
@@ -166,38 +151,35 @@ export async function ensureSsoConfig() {
   console.log(chalk.cyan("\n  AWS SSO is not configured. Let's set it up.\n"));
   console.log(chalk.dim("  You can find these values in your AWS SSO portal.\n"));
 
-  const sessionName = await ask("SSO session name", "meshx");
-  const startUrl = await ask("SSO start URL");
-  const ssoRegion = await ask("SSO region", "us-east-1");
-  const accountId = await ask("AWS account ID");
-  const roleName = await ask("SSO role name", "AdministratorAccess");
-  const region = await ask("Default region", ssoRegion);
-  const profileName = await ask("Profile name", "dev");
-
-  if (!startUrl || !accountId) {
-    throw new Error("SSO start URL and account ID are required");
-  }
+  const answers = await inquirer.prompt([
+    { type: "input", name: "sessionName", message: "SSO session name:", default: "me-central-1" },
+    { type: "input", name: "startUrl", message: "SSO start URL:", validate: (v) => v?.trim() ? true : "Required." },
+    { type: "input", name: "ssoRegion", message: "SSO region:", default: "us-east-1" },
+    { type: "input", name: "accountId", message: "AWS account ID:", validate: (v) => /^\d{12}$/.test(v?.trim()) ? true : "Must be 12 digits." },
+    { type: "input", name: "roleName", message: "SSO role name:", default: "AdministratorAccess" },
+    { type: "input", name: "profileName", message: "Profile name:", default: "dev" },
+    { type: "input", name: "region", message: "Default region:", default: (a) => a.ssoRegion },
+  ]);
 
   // Ensure ~/.aws directory exists
   const awsDir = path.join(os.homedir(), ".aws");
   if (!fs.existsSync(awsDir)) fs.mkdirSync(awsDir, { mode: 0o700 });
 
-  const block = `
-[sso-session ${sessionName}]
-sso_start_url = ${startUrl}
-sso_region = ${ssoRegion}
+  const block = `[sso-session ${answers.sessionName.trim()}]
+sso_start_url = ${answers.startUrl.trim()}
+sso_region = ${answers.ssoRegion.trim()}
 sso_registration_scopes = sso:account:access
 
-[profile ${profileName}]
-sso_session = ${sessionName}
-sso_account_id = ${accountId}
-sso_role_name = ${roleName}
-region = ${region}
+[profile ${answers.profileName.trim()}]
+sso_session = ${answers.sessionName.trim()}
+sso_account_id = ${answers.accountId.trim()}
+sso_role_name = ${answers.roleName.trim()}
+region = ${answers.region.trim()}
 output = json
 `;
 
-  fs.appendFileSync(configPath, block);
-  console.log(chalk.green(`\n  ✓ Written to ~/.aws/config (profile: ${profileName})`));
+  fs.writeFileSync(configPath, block);
+  console.log(chalk.green(`\n  ✓ Written to ~/.aws/config (profile: ${answers.profileName.trim()})`));
 }
 
 /**
@@ -220,13 +202,44 @@ export async function fixAwsSso() {
   let ttyFd;
   try { ttyFd = fs.openSync("/dev/tty", "r"); } catch { ttyFd = null; }
 
-  await execa("aws", ["sso", "login", "--profile", profile.name], {
+  const { exitCode } = await execa("aws", ["sso", "login", "--profile", profile.name], {
     stdio: [ttyFd ?? "inherit", "inherit", "inherit"],
     reject: false,
     timeout: 120_000,
   });
 
   if (ttyFd !== null) fs.closeSync(ttyFd);
+
+  if (exitCode !== 0) {
+    // SSO login failed — likely bad config. Remove it and re-run setup.
+    console.log(chalk.yellow("  SSO login failed — re-running setup with new values...\n"));
+    const configPath = path.join(os.homedir(), ".aws", "config");
+    if (fs.existsSync(configPath)) fs.unlinkSync(configPath);
+    await ensureSsoConfig();
+
+    const retryProfiles = detectAwsSsoProfiles();
+    if (retryProfiles.length === 0) {
+      throw new Error("No SSO profiles found after config — check ~/.aws/config");
+    }
+
+    const retryProfile = retryProfiles[0];
+    console.log(chalk.cyan(`  ▶ aws sso login --profile ${retryProfile.name}`));
+
+    let retryTtyFd;
+    try { retryTtyFd = fs.openSync("/dev/tty", "r"); } catch { retryTtyFd = null; }
+
+    const { exitCode: retryCode } = await execa("aws", ["sso", "login", "--profile", retryProfile.name], {
+      stdio: [retryTtyFd ?? "inherit", "inherit", "inherit"],
+      reject: false,
+      timeout: 120_000,
+    });
+
+    if (retryTtyFd !== null) fs.closeSync(retryTtyFd);
+
+    if (retryCode !== 0) {
+      throw new Error("SSO login failed. Check your SSO start URL and region in ~/.aws/config");
+    }
+  }
 }
 
 /**

package/src/setup/setup.js

@@ -109,6 +109,7 @@ export function runSetup(dir, opts = {}) {
           } catch {
             console.log(chalk.yellow("\n⚠ Some images failed to download."));
           }
+          console.log("");
           console.log(chalk.green("Setup complete. Run: fops up"));
           return;
         }
@@ -162,6 +163,7 @@ export function runSetup(dir, opts = {}) {
         console.log(chalk.dim("  Then re-run: fops init --download\n"));
       }
     }
+    console.log("");
     console.log(chalk.green("Setup complete. Run: fops up"));
   })();
 }

package/src/setup/wizard.js

@@ -8,6 +8,60 @@ import { isFoundationRoot, findComposeRootUp } from "../project.js";
 import { discoverPlugins } from "../plugins/discovery.js";
 import { validateManifest } from "../plugins/manifest.js";
 import { runSetup, CLONE_BRANCH } from "./setup.js";
+import { confirm } from "../ui/index.js";
+
+/**
+ * Ensure Homebrew is available (macOS). Installs if missing.
+ */
+async function ensureBrew() {
+  try { await execa("brew", ["--version"]); return true; } catch {}
+  console.log(chalk.cyan("  ▶ Installing Homebrew…"));
+  try {
+    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,
+    });
+    const brewPaths = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"];
+    for (const bp of brewPaths) {
+      if (fs.existsSync(bp)) { process.env.PATH = path.dirname(bp) + ":" + process.env.PATH; break; }
+    }
+    return true;
+  } catch { return false; }
+}
+
+/**
+ * Try to install a missing tool. Returns true if installed successfully.
+ */
+async function installTool(name, { brew, brewCask, winget, apt, npm: npmPkg } = {}) {
+  const shouldInstall = await confirm(`  Install ${name}?`, true);
+  if (!shouldInstall) return false;
+  try {
+    if (process.platform === "darwin" && (brew || brewCask)) {
+      if (!(await ensureBrew())) { console.log(chalk.red("  Homebrew required")); return false; }
+      const cmd = brewCask ? ["install", "--cask", brewCask] : ["install", brew];
+      console.log(chalk.cyan(`  ▶ brew ${cmd.join(" ")}`));
+      await execa("brew", cmd, { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (process.platform === "win32" && winget) {
+      console.log(chalk.cyan(`  ▶ winget install ${winget}`));
+      await execa("winget", ["install", winget, "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (process.platform === "linux" && apt) {
+      console.log(chalk.cyan(`  ▶ sudo apt-get install -y ${apt}`));
+      await execa("sudo", ["apt-get", "install", "-y", apt], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+    if (npmPkg) {
+      console.log(chalk.cyan(`  ▶ npm install`));
+      await execa("npm", ["install"], { stdio: "inherit", timeout: 300_000 });
+      return true;
+    }
+  } catch (err) {
+    console.log(chalk.red(`  Failed to install ${name}: ${err.message}`));
+  }
+  return false;
+}
 
 export async function runInitWizard() {
   const cwd = process.cwd();
@@ -30,19 +84,76 @@ export async function runInitWizard() {
       projectRoot = foundUp;
     }
     if (!projectRoot) {
-      let hasGit = false, hasDocker = false, hasAws = false, hasClaude = false;
-      try { await execa("git", ["--version"]); hasGit = true; } catch {}
+      // ── Check prerequisites and offer to install missing ones ──
+      const getVer = async (cmd, args = ["--version"]) => {
+        try { const { stdout } = await execa(cmd, args, { reject: false, timeout: 5000 }); return stdout?.split("\n")[0]?.trim() || null; } catch { return null; }
+      };
+
+      let hasGit = !!(await getVer("git"));
+      let hasDocker = false;
       try { await execa("docker", ["info"], { timeout: 5000 }); hasDocker = true; } catch {}
-      try { await execa("aws", ["--version"]); hasAws = true; } catch {}
-      try { await execa("claude", ["--version"]); hasClaude = true; } catch {}
+      let hasAws = !!(await getVer("aws"));
+      let hasClaude = !!(await getVer("claude"));
+      let hasOp = !!(await getVer("op"));
+
       console.log(chalk.cyan("  Prerequisites\n"));
-      console.log(hasGit ? chalk.green("  ✓ Git") : chalk.red("  ✗ Git — install git first"));
-      console.log(hasDocker ? chalk.green("  ✓ Docker") : chalk.red("  ✗ Docker — install and start Docker Desktop"));
-      console.log(hasClaude ? chalk.green("  ✓ Claude CLI") : chalk.red("  ✗ Claude CLI — run: npm install (included as a dependency)"));
-      console.log(hasAws ? chalk.green("  ✓ AWS CLI") : chalk.yellow("  ⚠ AWS CLI — install for ECR image pulls (brew install awscli)"));
+
+      // Git
+      if (hasGit) console.log(chalk.green("  ✓ Git"));
+      else {
+        console.log(chalk.red("  ✗ Git"));
+        hasGit = await installTool("Git", { brew: "git", winget: "Git.Git", apt: "git" });
+      }
+
+      // Docker
+      if (hasDocker) console.log(chalk.green("  ✓ Docker"));
+      else {
+        console.log(chalk.red("  ✗ Docker"));
+        hasDocker = await installTool("Docker Desktop", { brewCask: "docker", winget: "Docker.DockerDesktop" });
+        if (hasDocker && process.platform === "darwin") {
+          console.log(chalk.cyan("  ▶ open -a Docker"));
+          await execa("open", ["-a", "Docker"], { timeout: 10000 }).catch(() => {});
+        }
+      }
+
+      // Claude CLI
+      if (hasClaude) console.log(chalk.green("  ✓ Claude CLI"));
+      else {
+        console.log(chalk.red("  ✗ Claude CLI"));
+        hasClaude = await installTool("Claude CLI", { npm: true });
+      }
+
+      // AWS CLI (optional)
+      if (hasAws) console.log(chalk.green("  ✓ AWS CLI"));
+      else {
+        console.log(chalk.yellow("  ⚠ AWS CLI") + chalk.dim(" — needed for ECR image pulls"));
+        hasAws = await installTool("AWS CLI", { brew: "awscli", winget: "Amazon.AWSCLI" });
+      }
+
+      // 1Password desktop app (optional — needed for CLI integration)
+      const has1PwdApp = process.platform === "darwin"
+        ? fs.existsSync("/Applications/1Password.app")
+        : process.platform === "win32"
+          ? fs.existsSync(path.join(process.env.LOCALAPPDATA || "", "1Password", "app", "8", "1Password.exe"))
+          : false;
+      if (has1PwdApp) console.log(chalk.green("  ✓ 1Password"));
+      else {
+        console.log(chalk.yellow("  ⚠ 1Password") + chalk.dim(" — desktop app needed for CLI integration"));
+        await installTool("1Password", { brewCask: "1password", winget: "AgileBits.1Password" });
+      }
+
+      // 1Password CLI (optional)
+      if (hasOp) console.log(chalk.green("  ✓ 1Password CLI"));
+      else {
+        console.log(chalk.yellow("  ⚠ 1Password CLI") + chalk.dim(" — needed for secret sync"));
+        hasOp = await installTool("1Password CLI", { brewCask: "1password-cli", winget: "AgileBits.1Password.CLI" });
+      }
+
+      // GitHub credentials
       const netrcPath = path.join(os.homedir(), ".netrc");
       const hasNetrc = fs.existsSync(netrcPath) && fs.readFileSync(netrcPath, "utf8").includes("machine github.com");
       console.log(hasNetrc ? chalk.green("  ✓ GitHub credentials (~/.netrc)") : chalk.yellow("  ⚠ GitHub credentials — add to ~/.netrc (needed for private submodules)"));
+
       // Cursor IDE (only when cursor plugin is installed)
       const cursorPluginDir = path.join(os.homedir(), ".fops", "plugins", "cursor");
       if (fs.existsSync(cursorPluginDir)) {
@@ -51,13 +162,27 @@ export async function runInitWizard() {
           const { stdout } = await execa("cursor", ["--version"]);
           cursorVer = (stdout || "").split("\n")[0].trim();
         } catch {}
-        console.log(cursorVer
-          ? chalk.green("  ✓ Cursor IDE") + chalk.dim(` — ${cursorVer}`)
-          : chalk.yellow("  ⚠ Cursor IDE — install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"));
+
+        if (cursorVer) {
+          console.log(chalk.green("  ✓ Cursor IDE") + chalk.dim(` — ${cursorVer}`));
+        } else {
+          // Check if Cursor app is installed even without CLI command
+          const appInstalled = process.platform === "darwin"
+            ? fs.existsSync("/Applications/Cursor.app")
+            : process.platform === "win32"
+              ? fs.existsSync(path.join(os.homedir(), "AppData", "Local", "Programs", "Cursor", "Cursor.exe"))
+              : false;
+          if (appInstalled) {
+            console.log(chalk.green("  ✓ Cursor IDE") + chalk.dim(" — app installed (CLI not in PATH — Cmd+Shift+P → 'Install cursor command' to enable)"));
+          } else {
+            console.log(chalk.yellow("  ⚠ Cursor IDE — install from cursor.com, then: Cmd+Shift+P → 'Install cursor command'"));
+          }
+        }
       }
+
       console.log("");
       if (!hasGit || !hasDocker || !hasClaude) {
-        console.log(chalk.red("Fix the missing prerequisites above, then run fops init again.\n"));
+        console.log(chalk.red("  Required tools are still missing. Install them and run fops init again.\n"));
         process.exit(1);
       }
       const choices = [