@mangomagic/cli 0.1.4 → 0.1.5

package/README.md

@@ -20,7 +20,6 @@ at `~/.mangomagic/credentials.json` (mode 0600) so the next runs skip auth.
 | `mangomagic home` | Show fast wins after sign-in. |
 | `mangomagic chat` | Start an interactive natural-language session. |
 | `mangomagic ask "..."` | Run one natural-language request. |
-| `mangomagic key set` | Store a Moonshot/Kimi API key in macOS Keychain, or a mode-0600 fallback file on other platforms. |
 | `mangomagic tools` | Show available MCP tools and near-next workflows. Add `--json` for machine-readable output. |
 | `mangomagic cards` | Open the Talking Cards workspace. Add `--no-open` to print the URL only. |
 | `mangomagic splash` | Show the splash once. `--anim`, `--loop` supported. |
@@ -52,12 +51,8 @@ npx -y @mangomagic/cli chat
 npx -y @mangomagic/cli create talking cards about AI adoption
 ```
 
-Obvious requests are handled locally. Fuzzy routing uses Kimi K2.6 through the
-Moonshot API. Store the key securely:
-
-```bash
-npx -y @mangomagic/cli key set
-```
+Obvious requests are handled locally. Fuzzy routing uses MangoMagic's backend AI
+router, so end users never need to provide a Moonshot/Kimi key.
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mangomagic/cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "MangoMagic CLI — sign in, manage episodes, and expose MangoMagic to MCP clients (Claude Desktop, Cursor).",
   "type": "module",
   "bin": {

package/src/ai/kimi.mjs

@@ -1,66 +1,7 @@
-import { loadMoonshotKey } from "../secrets/moonshot-key-store.mjs";
-
-export class MissingMoonshotKeyError extends Error {
-  constructor() {
-    super("Missing Moonshot API key.");
-    this.name = "MissingMoonshotKeyError";
-  }
-}
+import { apiCall } from "../api.mjs";
 
 export async function planWithKimi(userText, context = {}) {
-  const secret = loadMoonshotKey();
-  if (!secret?.key) throw new MissingMoonshotKeyError();
-
-  const response = await fetch("https://api.moonshot.ai/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${secret.key}`,
-    },
-    body: JSON.stringify({
-      model: "kimi-k2.6",
-      messages: [
-        {
-          role: "system",
-          content: `You route natural-language terminal requests for MangoMagic.
-
-Return only compact JSON. No markdown.
-
-Allowed actions:
-- open_cards: open the Talking Cards generator. Args: {"focus": optional string}
-- open_brand_doc: open Brand Doc setup/review.
-- show_tools: show available MCP tools.
-- mcp_config: print MCP config.
-- list_episodes: list recent episodes. Args: {"limit": integer 1-10}
-- search_episodes: search episodes. Args: {"query": string}
-- get_episode: get one episode. Args: {"episode": id or slug}
-- home: show fast wins.
-- answer: answer briefly without external action. Args: {"text": string}
-
-Prefer a direct tool action over a chatty answer. If the user asks to create talking cards, choose open_cards and preserve their idea as focus.`,
-        },
-        {
-          role: "user",
-          content: JSON.stringify({ userText, context }),
-        },
-      ],
-      thinking: { type: "disabled" },
-      max_tokens: 700,
-    }),
-  });
-
-  const bodyText = await response.text();
-  let body;
-  try { body = JSON.parse(bodyText); } catch { body = null; }
-
-  if (!response.ok) {
-    const message = body?.error?.message || body?.error || bodyText || `HTTP ${response.status}`;
-    throw new Error(`Kimi request failed: ${message}`);
-  }
-
-  const content = body?.choices?.[0]?.message?.content;
-  if (!content) throw new Error("Kimi returned no routing decision.");
-
-  const jsonText = String(content).trim().replace(/^```json\s*/i, "").replace(/^```\s*/i, "").replace(/```$/i, "").trim();
-  return JSON.parse(jsonText);
+  const result = await apiCall("cli-ai-route", { body: { text: userText, context } });
+  if (!result?.plan?.action) throw new Error("MangoMagic AI returned no routing decision.");
+  return result.plan;
 }

package/src/chat/natural-language.mjs

@@ -1,8 +1,7 @@
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { apiCall } from "../api.mjs";
-import { MissingMoonshotKeyError, planWithKimi } from "../ai/kimi.mjs";
-import { moonshotKeyStorageHint } from "../secrets/moonshot-key-store.mjs";
+import { planWithKimi } from "../ai/kimi.mjs";
 
 const GOLD = "\x1b[38;2;241;171;28m";
 const DIM = "\x1b[2m";
@@ -85,22 +84,16 @@ export async function handleNaturalLanguage(text, actions, { allowModel = true }
         availableTools: ["open_cards", "open_brand_doc", "show_tools", "mcp_config", "list_episodes", "search_episodes", "get_episode", "home"],
       });
     } catch (err) {
-      if (err instanceof MissingMoonshotKeyError) {
-        process.stdout.write(`
-${BOLD}Natural-language routing needs a Kimi API key for fuzzy requests.${RESET}
+      process.stdout.write(`
+${BOLD}MangoMagic AI routing is unavailable right now.${RESET}
 
 Obvious commands still work, for example:
   ${GOLD}npx -y @mangomagic/cli create talking cards${RESET}
   ${GOLD}npx -y @mangomagic/cli search episodes for AI adoption${RESET}
 
-Set Kimi up securely:
-  ${GOLD}npx -y @mangomagic/cli key set${RESET}
-
-Storage: ${moonshotKeyStorageHint()}
+${DIM}${err?.message ?? err}${RESET}
 `);
-        return;
-      }
-      throw err;
+      return;
     }
   }
 

package/src/index.mjs

@@ -2,10 +2,8 @@ import { deviceLogin } from "./auth/device-flow.mjs";
 import { chat, handleNaturalLanguage } from "./chat/natural-language.mjs";
 import { loadToken, saveToken, clearToken, credentialsPath } from "./auth/token-store.mjs";
 import { APP_ORIGIN } from "./config.mjs";
-import { clearMoonshotKey, loadMoonshotKey, moonshotKeyStorageHint, saveMoonshotKey } from "./secrets/moonshot-key-store.mjs";
 import { openUrl } from "./system/open-url.mjs";
 import { COMMAND_PREFIX, MCP_TOOL_CATALOG, NEXT_WORKFLOWS, QUICK_WINS } from "./tools/catalog.mjs";
-import { promptHidden } from "./ui/prompt-hidden.mjs";
 import { playSplash } from "./ui/splash.mjs";
 
 const GOLD = "\x1b[38;2;241;171;28m";
@@ -22,7 +20,6 @@ ${BOLD}mangomagic${RESET}  ${DIM}— sign into MangoMagic and bring your account
   ${GOLD}mangomagic whoami${RESET}      Show the cached identity.
   ${GOLD}mangomagic home${RESET}        Show fast wins for creating value right now.
   ${GOLD}mangomagic chat${RESET}        Talk to MangoMagic in natural language.
-  ${GOLD}mangomagic key set${RESET}     Store a Moonshot/Kimi API key securely.
   ${GOLD}mangomagic tools${RESET}       Show available MCP tools and next workflows.
   ${GOLD}mangomagic cards${RESET}       Open the Talking Cards workspace.
   ${GOLD}mangomagic splash${RESET}      Show the MangoMagic splash once. Add --anim or --loop for motion.
@@ -169,29 +166,6 @@ function mcpConfig() {
   process.stdout.write(JSON.stringify(cfg, null, 2) + "\n");
 }
 
-async function keyCommand(argv) {
-  const sub = argv[0] || "status";
-  if (sub === "set") {
-    const key = await promptHidden("Moonshot API key: ");
-    const where = saveMoonshotKey(key);
-    process.stdout.write(`Saved Moonshot API key in ${where}.\n`);
-    return;
-  }
-  if (sub === "clear" || sub === "delete" || sub === "remove") {
-    const cleared = clearMoonshotKey();
-    process.stdout.write(cleared ? "Moonshot API key removed.\n" : "No stored Moonshot API key found.\n");
-    return;
-  }
-  if (sub === "status") {
-    const key = loadMoonshotKey();
-    if (key) process.stdout.write(`Moonshot API key found via ${key.source}.\n`);
-    else process.stdout.write(`No Moonshot API key found. Store one with \`${COMMAND_PREFIX} key set\`.\nStorage: ${moonshotKeyStorageHint()}\n`);
-    return;
-  }
-  process.stderr.write(`Unknown key command: ${sub}\n`);
-  process.exit(2);
-}
-
 function actions() {
   return { cards, openPath, tools, mcpConfig, home };
 }
@@ -205,8 +179,6 @@ export async function run(argv) {
     case "home":       return home();
     case "chat":       return chat(actions());
     case "ask":        return handleNaturalLanguage(argv.slice(1).join(" "), actions());
-    case "key":
-    case "kimi-key":   return keyCommand(argv.slice(1));
     case "tools":      return tools({ json: argv.includes("--json") });
     case "cards":      return cards({ openInBrowser: !argv.includes("--no-open") && process.env.MANGOMAGIC_CLI_NO_OPEN !== "1" });
     case "splash":     return playSplash({ mode: argv.includes("--loop") ? "loop" : argv.includes("--anim") ? "anim" : "static" });

package/src/secrets/moonshot-key-store.mjs

@@ -1,110 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, chmodSync } from "node:fs";
-import { homedir, userInfo } from "node:os";
-import { join } from "node:path";
-
-const SERVICE = "mangomagic.moonshot.api-key";
-const dir = join(homedir(), ".mangomagic");
-const fallbackFile = join(dir, "moonshot.json");
-
-function account() {
-  return process.env.USER || userInfo().username || "default";
-}
-
-function canUseKeychain() {
-  return process.platform === "darwin" && existsSync("/usr/bin/security");
-}
-
-function readKeychain() {
-  if (!canUseKeychain()) return null;
-  try {
-    const key = execFileSync("/usr/bin/security", [
-      "find-generic-password",
-      "-a", account(),
-      "-s", SERVICE,
-      "-w",
-    ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    return key || null;
-  } catch {
-    return null;
-  }
-}
-
-function writeKeychain(key) {
-  execFileSync("/usr/bin/security", [
-    "add-generic-password",
-    "-a", account(),
-    "-s", SERVICE,
-    "-w", key,
-    "-U",
-  ], { stdio: "ignore" });
-}
-
-function clearKeychain() {
-  if (!canUseKeychain()) return false;
-  try {
-    execFileSync("/usr/bin/security", [
-      "delete-generic-password",
-      "-a", account(),
-      "-s", SERVICE,
-    ], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function readFallback() {
-  if (!existsSync(fallbackFile)) return null;
-  try {
-    const raw = JSON.parse(readFileSync(fallbackFile, "utf8"));
-    return typeof raw?.apiKey === "string" ? raw.apiKey : null;
-  } catch {
-    return null;
-  }
-}
-
-function writeFallback(key) {
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(fallbackFile, JSON.stringify({ apiKey: key }, null, 2));
-  try { chmodSync(fallbackFile, 0o600); } catch { /* windows */ }
-}
-
-export function loadMoonshotKey() {
-  if (process.env.MOONSHOT_API_KEY) return { key: process.env.MOONSHOT_API_KEY, source: "MOONSHOT_API_KEY" };
-  const keychainKey = readKeychain();
-  if (keychainKey) return { key: keychainKey, source: "macOS Keychain" };
-  const fileKey = readFallback();
-  if (fileKey) return { key: fileKey, source: fallbackFile };
-  return null;
-}
-
-export function saveMoonshotKey(key) {
-  if (!key || typeof key !== "string") throw new Error("Missing API key.");
-  const trimmed = key.trim();
-  if (!trimmed) throw new Error("Missing API key.");
-
-  if (canUseKeychain()) {
-    writeKeychain(trimmed);
-    return "macOS Keychain";
-  }
-
-  writeFallback(trimmed);
-  return fallbackFile;
-}
-
-export function clearMoonshotKey() {
-  const keychainCleared = clearKeychain();
-  let fileCleared = false;
-  if (existsSync(fallbackFile)) {
-    unlinkSync(fallbackFile);
-    fileCleared = true;
-  }
-  return keychainCleared || fileCleared;
-}
-
-export function moonshotKeyStorageHint() {
-  return canUseKeychain()
-    ? "macOS Keychain service mangomagic.moonshot.api-key"
-    : `${fallbackFile} (mode 0600) or MOONSHOT_API_KEY`;
-}

package/src/ui/prompt-hidden.mjs

@@ -1,45 +0,0 @@
-export function promptHidden(prompt) {
-  return new Promise((resolve, reject) => {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    let value = "";
-    let rawWasEnabled = false;
-
-    function cleanup() {
-      stdin.off("data", onData);
-      if (rawWasEnabled && stdin.isTTY) stdin.setRawMode(false);
-      stdin.pause();
-      stdout.write("\n");
-    }
-
-    function onData(chunk) {
-      const s = String(chunk);
-      for (const ch of s) {
-        if (ch === "\u0003") {
-          cleanup();
-          reject(new Error("Cancelled."));
-          return;
-        }
-        if (ch === "\r" || ch === "\n") {
-          cleanup();
-          resolve(value);
-          return;
-        }
-        if (ch === "\u007f" || ch === "\b") {
-          value = value.slice(0, -1);
-          continue;
-        }
-        value += ch;
-      }
-    }
-
-    stdout.write(prompt);
-    stdin.resume();
-    stdin.setEncoding("utf8");
-    if (stdin.isTTY) {
-      stdin.setRawMode(true);
-      rawWasEnabled = true;
-    }
-    stdin.on("data", onData);
-  });
-}