@learnrudi/cli 1.9.2 → 1.9.3

package/dist/index.cjs

@@ -3834,6 +3834,452 @@ After configuring secrets, run: rudi index`);
   }
 }
 
+// src/commands/status.js
+var import_core12 = require("@learnrudi/core");
+var import_child_process7 = require("child_process");
+var import_fs10 = __toESM(require("fs"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_os4 = __toESM(require("os"), 1);
+var AGENTS = [
+  {
+    id: "claude",
+    name: "Claude Code",
+    npmPackage: "@anthropic-ai/claude-code",
+    credentialType: "keychain",
+    keychainService: "Claude Code-credentials"
+  },
+  {
+    id: "codex",
+    name: "OpenAI Codex",
+    npmPackage: "@openai/codex",
+    credentialType: "file",
+    credentialPath: "~/.codex/auth.json"
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    npmPackage: "@google/gemini-cli",
+    credentialType: "file",
+    credentialPath: "~/.gemini/google_accounts.json"
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    npmPackage: "@githubnext/github-copilot-cli",
+    credentialType: "file",
+    credentialPath: "~/.config/github-copilot/hosts.json"
+  }
+];
+var RUNTIMES = [
+  { id: "node", name: "Node.js", command: "node", versionFlag: "--version" },
+  { id: "python", name: "Python", command: "python3", versionFlag: "--version" },
+  { id: "deno", name: "Deno", command: "deno", versionFlag: "--version" },
+  { id: "bun", name: "Bun", command: "bun", versionFlag: "--version" }
+];
+var BINARIES = [
+  { id: "ffmpeg", name: "FFmpeg", command: "ffmpeg", versionFlag: "-version" },
+  { id: "ripgrep", name: "ripgrep", command: "rg", versionFlag: "--version" },
+  { id: "git", name: "Git", command: "git", versionFlag: "--version" },
+  { id: "pandoc", name: "Pandoc", command: "pandoc", versionFlag: "--version" },
+  { id: "jq", name: "jq", command: "jq", versionFlag: "--version" }
+];
+function fileExists(filePath) {
+  const resolved = filePath.replace("~", import_os4.default.homedir());
+  return import_fs10.default.existsSync(resolved);
+}
+function checkKeychain(service) {
+  if (process.platform !== "darwin") return false;
+  try {
+    (0, import_child_process7.execSync)(`security find-generic-password -s "${service}"`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getVersion(command, versionFlag) {
+  try {
+    const output = (0, import_child_process7.execSync)(`${command} ${versionFlag} 2>&1`, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const match = output.match(/(\d+\.\d+\.?\d*)/);
+    return match ? match[1] : output.trim().split("\n")[0].slice(0, 50);
+  } catch {
+    return null;
+  }
+}
+function findBinary(command, kind = "binary") {
+  const rudiPaths = [
+    import_path7.default.join(import_core12.PATHS.agents, command, "node_modules", ".bin", command),
+    import_path7.default.join(import_core12.PATHS.runtimes, command, "bin", command),
+    import_path7.default.join(import_core12.PATHS.binaries, command, command),
+    import_path7.default.join(import_core12.PATHS.binaries, command)
+  ];
+  for (const p of rudiPaths) {
+    if (import_fs10.default.existsSync(p)) {
+      return { found: true, path: p, source: "rudi" };
+    }
+  }
+  try {
+    const output = (0, import_child_process7.execSync)(`which ${command} 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    const globalPath = output.trim();
+    if (globalPath) {
+      return { found: true, path: globalPath, source: "global" };
+    }
+  } catch {
+  }
+  return { found: false, path: null, source: null };
+}
+function getAgentStatus(agent) {
+  const binaryPath = import_path7.default.join(import_core12.PATHS.agents, agent.id, "node_modules", ".bin", agent.id);
+  const installed = import_fs10.default.existsSync(binaryPath);
+  let authenticated = false;
+  if (agent.credentialType === "keychain") {
+    authenticated = checkKeychain(agent.keychainService);
+  } else if (agent.credentialType === "file") {
+    authenticated = fileExists(agent.credentialPath);
+  }
+  let version = null;
+  if (installed) {
+    version = getVersion(binaryPath, "--version");
+  }
+  return {
+    id: agent.id,
+    name: agent.name,
+    installed,
+    authenticated,
+    version,
+    path: installed ? binaryPath : null,
+    ready: installed && authenticated
+  };
+}
+function getRuntimeStatus(runtime) {
+  const location = findBinary(runtime.command, "runtime");
+  const version = location.found ? getVersion(location.path, runtime.versionFlag) : null;
+  return {
+    id: runtime.id,
+    name: runtime.name,
+    installed: location.found,
+    version,
+    path: location.path,
+    source: location.source
+  };
+}
+function getBinaryStatus(binary) {
+  const location = findBinary(binary.command, "binary");
+  const version = location.found ? getVersion(location.path, binary.versionFlag) : null;
+  return {
+    id: binary.id,
+    name: binary.name,
+    installed: location.found,
+    version,
+    path: location.path,
+    source: location.source
+  };
+}
+async function getFullStatus() {
+  const agents = AGENTS.map(getAgentStatus);
+  const runtimes = RUNTIMES.map(getRuntimeStatus);
+  const binaries = BINARIES.map(getBinaryStatus);
+  let stacks = [];
+  let prompts = [];
+  try {
+    stacks = (0, import_core12.getInstalledPackages)("stack").map((s) => ({
+      id: s.id,
+      name: s.name,
+      version: s.version
+    }));
+    prompts = (0, import_core12.getInstalledPackages)("prompt").map((p) => ({
+      id: p.id,
+      name: p.name,
+      category: p.category
+    }));
+  } catch {
+  }
+  const directories = {
+    home: { path: import_core12.PATHS.home, exists: import_fs10.default.existsSync(import_core12.PATHS.home) },
+    stacks: { path: import_core12.PATHS.stacks, exists: import_fs10.default.existsSync(import_core12.PATHS.stacks) },
+    agents: { path: import_core12.PATHS.agents, exists: import_fs10.default.existsSync(import_core12.PATHS.agents) },
+    runtimes: { path: import_core12.PATHS.runtimes, exists: import_fs10.default.existsSync(import_core12.PATHS.runtimes) },
+    binaries: { path: import_core12.PATHS.binaries, exists: import_fs10.default.existsSync(import_core12.PATHS.binaries) },
+    db: { path: import_core12.PATHS.db, exists: import_fs10.default.existsSync(import_core12.PATHS.db) }
+  };
+  const summary = {
+    agentsInstalled: agents.filter((a) => a.installed).length,
+    agentsReady: agents.filter((a) => a.ready).length,
+    agentsTotal: agents.length,
+    runtimesInstalled: runtimes.filter((r) => r.installed).length,
+    runtimesTotal: runtimes.length,
+    binariesInstalled: binaries.filter((b) => b.installed).length,
+    binariesTotal: binaries.length,
+    stacksInstalled: stacks.length,
+    promptsInstalled: prompts.length
+  };
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: `${process.platform}-${process.arch}`,
+    rudiHome: import_core12.PATHS.home,
+    summary,
+    agents,
+    runtimes,
+    binaries,
+    stacks,
+    prompts,
+    directories
+  };
+}
+function printStatus(status, filter) {
+  console.log("RUDI Status");
+  console.log("=".repeat(50));
+  console.log(`Platform: ${status.platform}`);
+  console.log(`RUDI Home: ${status.rudiHome}`);
+  console.log("");
+  if (!filter || filter === "agents") {
+    console.log(`AGENTS (${status.summary.agentsReady}/${status.summary.agentsTotal} ready)`);
+    console.log("-".repeat(50));
+    for (const agent of status.agents) {
+      const installIcon = agent.installed ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+      const authIcon = agent.authenticated ? "\x1B[32m\u2713\x1B[0m" : "\x1B[33m\u25CB\x1B[0m";
+      const version = agent.version ? `v${agent.version}` : "";
+      console.log(`  ${installIcon} ${agent.name} ${version}`);
+      console.log(`    Installed: ${agent.installed ? "yes" : "no"}, Auth: ${agent.authenticated ? "yes" : "no"}`);
+    }
+    console.log("");
+  }
+  if (!filter || filter === "runtimes") {
+    console.log(`RUNTIMES (${status.summary.runtimesInstalled}/${status.summary.runtimesTotal})`);
+    console.log("-".repeat(50));
+    for (const rt of status.runtimes) {
+      const icon = rt.installed ? "\x1B[32m\u2713\x1B[0m" : "\x1B[90m\u25CB\x1B[0m";
+      const version = rt.version ? `v${rt.version}` : "";
+      const source = rt.source ? `(${rt.source})` : "";
+      console.log(`  ${icon} ${rt.name} ${version} ${source}`);
+    }
+    console.log("");
+  }
+  if (!filter || filter === "binaries") {
+    console.log(`BINARIES (${status.summary.binariesInstalled}/${status.summary.binariesTotal})`);
+    console.log("-".repeat(50));
+    for (const bin of status.binaries) {
+      const icon = bin.installed ? "\x1B[32m\u2713\x1B[0m" : "\x1B[90m\u25CB\x1B[0m";
+      const version = bin.version ? `v${bin.version}` : "";
+      const source = bin.source ? `(${bin.source})` : "";
+      console.log(`  ${icon} ${bin.name} ${version} ${source}`);
+    }
+    console.log("");
+  }
+  if (!filter || filter === "stacks") {
+    console.log(`STACKS (${status.summary.stacksInstalled})`);
+    console.log("-".repeat(50));
+    if (status.stacks.length === 0) {
+      console.log("  No stacks installed");
+    } else {
+      for (const stack of status.stacks) {
+        console.log(`  ${stack.id} v${stack.version || "?"}`);
+      }
+    }
+    console.log("");
+  }
+  console.log("SUMMARY");
+  console.log("-".repeat(50));
+  console.log(`  Agents ready: ${status.summary.agentsReady}/${status.summary.agentsTotal}`);
+  console.log(`  Runtimes: ${status.summary.runtimesInstalled}/${status.summary.runtimesTotal}`);
+  console.log(`  Binaries: ${status.summary.binariesInstalled}/${status.summary.binariesTotal}`);
+  console.log(`  Stacks: ${status.summary.stacksInstalled}`);
+  console.log(`  Prompts: ${status.summary.promptsInstalled}`);
+}
+async function cmdStatus(args, flags) {
+  const filter = args[0];
+  const status = await getFullStatus();
+  if (flags.json) {
+    if (filter) {
+      const filtered = {
+        timestamp: status.timestamp,
+        platform: status.platform,
+        [filter]: status[filter]
+      };
+      console.log(JSON.stringify(filtered, null, 2));
+    } else {
+      console.log(JSON.stringify(status, null, 2));
+    }
+  } else {
+    printStatus(status, filter);
+  }
+}
+
+// src/commands/check.js
+var import_core13 = require("@learnrudi/core");
+var import_child_process8 = require("child_process");
+var import_fs11 = __toESM(require("fs"), 1);
+var import_path8 = __toESM(require("path"), 1);
+var import_os5 = __toESM(require("os"), 1);
+var AGENT_CREDENTIALS = {
+  claude: { type: "keychain", service: "Claude Code-credentials" },
+  codex: { type: "file", path: "~/.codex/auth.json" },
+  gemini: { type: "file", path: "~/.gemini/google_accounts.json" },
+  copilot: { type: "file", path: "~/.config/github-copilot/hosts.json" }
+};
+function fileExists2(filePath) {
+  const resolved = filePath.replace("~", import_os5.default.homedir());
+  return import_fs11.default.existsSync(resolved);
+}
+function checkKeychain2(service) {
+  if (process.platform !== "darwin") return false;
+  try {
+    (0, import_child_process8.execSync)(`security find-generic-password -s "${service}"`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getVersion2(binaryPath, versionFlag = "--version") {
+  try {
+    const output = (0, import_child_process8.execSync)(`"${binaryPath}" ${versionFlag} 2>&1`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const match = output.match(/(\d+\.\d+\.?\d*)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function cmdCheck(args, flags) {
+  const packageId = args[0];
+  if (!packageId) {
+    console.error("Usage: rudi check <package-id>");
+    console.error("Examples:");
+    console.error("  rudi check agent:claude");
+    console.error("  rudi check runtime:python");
+    console.error("  rudi check binary:ffmpeg");
+    console.error("  rudi check stack:slack");
+    process.exit(1);
+  }
+  let kind, name;
+  if (packageId.includes(":")) {
+    [kind, name] = packageId.split(":");
+  } else {
+    if (["claude", "codex", "gemini", "copilot"].includes(packageId)) {
+      kind = "agent";
+      name = packageId;
+    } else if (["node", "python", "deno", "bun"].includes(packageId)) {
+      kind = "runtime";
+      name = packageId;
+    } else {
+      kind = "stack";
+      name = packageId;
+    }
+  }
+  const result = {
+    id: `${kind}:${name}`,
+    kind,
+    name,
+    installed: false,
+    authenticated: null,
+    // Only for agents
+    ready: false,
+    path: null,
+    version: null
+  };
+  switch (kind) {
+    case "agent": {
+      const binaryPath = import_path8.default.join(import_core13.PATHS.agents, name, "node_modules", ".bin", name);
+      result.installed = import_fs11.default.existsSync(binaryPath);
+      result.path = result.installed ? binaryPath : null;
+      if (result.installed) {
+        result.version = getVersion2(binaryPath);
+      }
+      const cred = AGENT_CREDENTIALS[name];
+      if (cred) {
+        if (cred.type === "keychain") {
+          result.authenticated = checkKeychain2(cred.service);
+        } else if (cred.type === "file") {
+          result.authenticated = fileExists2(cred.path);
+        }
+      }
+      result.ready = result.installed && result.authenticated;
+      break;
+    }
+    case "runtime": {
+      const rudiPath = import_path8.default.join(import_core13.PATHS.runtimes, name, "bin", name);
+      if (import_fs11.default.existsSync(rudiPath)) {
+        result.installed = true;
+        result.path = rudiPath;
+        result.version = getVersion2(rudiPath);
+      } else {
+        try {
+          const globalPath = (0, import_child_process8.execSync)(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
+          if (globalPath) {
+            result.installed = true;
+            result.path = globalPath;
+            result.version = getVersion2(globalPath);
+          }
+        } catch {
+        }
+      }
+      result.ready = result.installed;
+      break;
+    }
+    case "binary": {
+      const rudiPath = import_path8.default.join(import_core13.PATHS.binaries, name, name);
+      if (import_fs11.default.existsSync(rudiPath)) {
+        result.installed = true;
+        result.path = rudiPath;
+      } else {
+        try {
+          const globalPath = (0, import_child_process8.execSync)(`which ${name} 2>/dev/null`, { encoding: "utf-8" }).trim();
+          if (globalPath) {
+            result.installed = true;
+            result.path = globalPath;
+          }
+        } catch {
+        }
+      }
+      result.ready = result.installed;
+      break;
+    }
+    case "stack": {
+      result.installed = (0, import_core13.isPackageInstalled)(`stack:${name}`);
+      if (result.installed) {
+        result.path = (0, import_core13.getPackagePath)(`stack:${name}`);
+      }
+      result.ready = result.installed;
+      break;
+    }
+    default:
+      console.error(`Unknown package kind: ${kind}`);
+      process.exit(1);
+  }
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const installIcon = result.installed ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`${installIcon} ${result.id}`);
+    console.log(`  Installed: ${result.installed}`);
+    if (result.path) console.log(`  Path: ${result.path}`);
+    if (result.version) console.log(`  Version: ${result.version}`);
+    if (result.authenticated !== null) {
+      console.log(`  Authenticated: ${result.authenticated}`);
+    }
+    console.log(`  Ready: ${result.ready}`);
+  }
+  if (!result.installed) {
+    process.exit(1);
+  } else if (result.authenticated === false) {
+    process.exit(2);
+  } else {
+    process.exit(0);
+  }
+}
+
 // src/index.js
 var VERSION = "2.0.0";
 async function main() {
@@ -3881,7 +4327,6 @@ async function main() {
         await cmdImport(args, flags);
         break;
       case "doctor":
-      case "check":
         await cmdDoctor(args, flags);
         break;
       case "init":
@@ -3919,9 +4364,14 @@ async function main() {
         await cmdIndex(args, flags);
         break;
       case "home":
-      case "status":
         await cmdHome(args, flags);
         break;
+      case "status":
+        await cmdStatus(args, flags);
+        break;
+      case "check":
+        await cmdCheck(args, flags);
+        break;
       // Shortcuts for listing specific package types
       case "stacks":
         await cmdList(["stacks"], flags);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learnrudi/cli",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "description": "RUDI CLI - Install and manage MCP stacks, runtimes, and AI agents",
   "type": "module",
   "main": "dist/index.cjs",