metheus-governance-mcp-cli 0.2.65 → 0.2.67

package/README.md

@@ -226,7 +226,12 @@ Behavior:
 
 - `bot setup` asks for `Telegram / Slack / KakaoTalk` first, then prompts with numbered actions.
 - `bot add` without flags starts a guided question flow: provider -> server bot -> local bot key -> token -> verify -> role/AI binding -> default bot choice.
+- When you choose a server Telegram bot profile such as `RyoAI_bot [monitor]`, the CLI automatically uses that server role as the local `role_profile` and fills blank AI defaults from your local `bot-runner.json` `role_profiles` mapping.
 - `bot edit` without flags starts a guided numbered flow: provider -> bot entry -> guided edit -> step-by-step field choices.
+- In guided `bot edit`, changing the bound server Telegram bot profile can also auto-fill blank local AI fields from the selected server role.
+- `bot set-default` without flags starts a guided numbered flow: provider -> bot entry -> confirm default change.
+- `bot verify` without flags starts a guided numbered flow: provider -> bot entry -> output format.
+- `bot remove` without flags starts a guided numbered flow: provider -> bot entry -> confirm removal.
 - Telegram supports named local bot entries with:
   - `SERVER_BOT_ID`
   - `USERNAME`

package/lib/bot-commands.mjs

@@ -182,6 +182,26 @@ async function promptYesNo(ui, promptText, defaultValue = true) {
   }
 }
 
+async function promptConfirmChoice(
+  ui,
+  title,
+  {
+    confirmLabel = "Confirm",
+    confirmDescription = "",
+    cancelLabel = "Cancel",
+    cancelDescription = "",
+    defaultValue = "confirm",
+  } = {},
+) {
+  const options = [
+    { value: "confirm", label: confirmLabel, description: confirmDescription },
+    { value: "cancel", label: cancelLabel, description: cancelDescription },
+  ];
+  const defaultIndex = defaultValue === "cancel" ? 1 : 0;
+  const selected = await promptChoice(ui, title, options, { defaultIndex });
+  return selected?.value === "confirm";
+}
+
 function formatChoiceLabel(option) {
   return `${String(option.label || option.value || "").trim()}${option.description ? ` - ${option.description}` : ""}`;
 }
@@ -493,6 +513,7 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     if (!current.roleProfile && serverBot.role) {
       current.roleProfile = serverBot.role;
     }
+    applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile || serverBot.role, deps));
   } else if (bindingAction === "clear") {
     current.serverBotID = "";
   }
@@ -540,6 +561,7 @@ async function editTelegramBotGuided(ui, parsed, selected, current, flags, deps)
     current.roleProfile = requireDependency(deps, "normalizeRunnerRoleProfileName")(
       await promptTelegramRoleProfile(ui, deps, current.roleProfile),
     );
+    applyRoleProfileDefaults(current, resolveRoleProfileDefaults(current.roleProfile, deps));
   } else if (roleAction === "clear") {
     current.roleProfile = "";
   }
@@ -921,6 +943,49 @@ async function promptReasoningEffort(ui, defaultValue = "") {
   return String(selected?.value || "").trim();
 }
 
+function resolveRoleProfileDefaults(roleProfileName, deps) {
+  const profileName = String(roleProfileName || "").trim();
+  if (!profileName) {
+    return {
+      client: "",
+      model: "",
+      permissionMode: "",
+      reasoningEffort: "",
+    };
+  }
+  const config = requireDependency(deps, "loadBotRunnerConfig")({ persistIfNeeded: true });
+  const profile = safeObject(safeObject(config.roleProfiles || {})[profileName]);
+  return {
+    client: requireDependency(deps, "normalizeLocalAIClientName")(profile.client || "", ""),
+    model: String(profile.model || "").trim(),
+    permissionMode: requireDependency(deps, "normalizeLocalAIPermissionMode")(
+      profile.permission_mode || profile.permissionMode || "",
+      "",
+    ),
+    reasoningEffort: requireDependency(deps, "normalizeLocalAIReasoningEffort")(
+      profile.reasoning_effort || profile.reasoningEffort || "",
+      "",
+    ),
+  };
+}
+
+function applyRoleProfileDefaults(entry, defaults, { overwrite = false } = {}) {
+  const current = safeObject(entry);
+  const resolved = safeObject(defaults);
+  if (overwrite || !String(current.client || "").trim()) {
+    current.client = String(resolved.client || "").trim();
+  }
+  if (overwrite || !String(current.model || "").trim()) {
+    current.model = String(resolved.model || "").trim();
+  }
+  if (overwrite || !String(current.permissionMode || "").trim()) {
+    current.permissionMode = String(resolved.permissionMode || "").trim();
+  }
+  if (overwrite || !String(current.reasoningEffort || "").trim()) {
+    current.reasoningEffort = String(resolved.reasoningEffort || "").trim();
+  }
+}
+
 function buildTemporaryTelegramEnvConfig({ token, apiBaseURL }) {
   return {
     ok: true,
@@ -1013,23 +1078,26 @@ async function addTelegramBot(ui, flags, deps) {
       ? String(flags["role-profile"] || defaultRoleProfile).trim()
       : await promptTelegramRoleProfile(ui, deps, defaultRoleProfile),
   );
+  const roleProfileDefaults = resolveRoleProfileDefaults(roleProfile, deps);
   const client = requireDependency(deps, "normalizeLocalAIClientName")(
     nonInteractive
-      ? getAIClientFlag(flags)
-      : await promptAIClient(ui, deps, getAIClientFlag(flags)),
+      ? firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client])
+      : await promptAIClient(ui, deps, firstNonEmptyString([getAIClientFlag(flags), roleProfileDefaults.client])),
     "",
   );
-  const model = nonInteractive ? getAIModelFlag(flags) : await promptLine(ui, "AI model", getAIModelFlag(flags));
+  const model = nonInteractive
+    ? firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model])
+    : await promptLine(ui, "AI model", firstNonEmptyString([getAIModelFlag(flags), roleProfileDefaults.model]));
   const permissionMode = requireDependency(deps, "normalizeLocalAIPermissionMode")(
     nonInteractive
-      ? getAIPermissionModeFlag(flags)
-      : await promptPermissionMode(ui, getAIPermissionModeFlag(flags)),
+      ? firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])
+      : await promptPermissionMode(ui, firstNonEmptyString([getAIPermissionModeFlag(flags), roleProfileDefaults.permissionMode])),
     "",
   );
   const reasoningEffort = requireDependency(deps, "normalizeLocalAIReasoningEffort")(
     nonInteractive
-      ? getAIReasoningEffortFlag(flags)
-      : await promptReasoningEffort(ui, getAIReasoningEffortFlag(flags)),
+      ? firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort])
+      : await promptReasoningEffort(ui, firstNonEmptyString([getAIReasoningEffortFlag(flags), roleProfileDefaults.reasoningEffort])),
     "",
   );
 
@@ -1262,7 +1330,13 @@ async function removeTelegramBot(ui, deps) {
   const parsed = { ...state.parsed };
   const selected = await chooseTelegramEntry(ui, parsed, deps, "Select Telegram bot entry to remove");
   if (!selected) return;
-  if (!await promptYesNo(ui, `Remove Telegram bot "${selected.key}"?`, false)) {
+  if (!await promptConfirmChoice(ui, `Remove Telegram bot "${selected.key}"?`, {
+    confirmLabel: "Remove bot",
+    confirmDescription: "delete this local Telegram bot entry",
+    cancelLabel: "Cancel",
+    cancelDescription: "keep the current local bot entry",
+    defaultValue: "cancel",
+  })) {
     process.stdout.write("Cancelled.\n");
     return;
   }
@@ -1338,7 +1412,23 @@ async function verifyProviderEntry(ui, provider, flags, deps) {
       }
     }
   }
-  if (boolFromRaw(flags.json, false)) {
+  const interactiveJsonChoice = (
+    !boolFromRaw(flags.json, false)
+    && !boolFromRaw(flags["non-interactive"] ?? flags.yes, false)
+  )
+    ? await promptChoice(
+      ui,
+      "Verification output format",
+      [
+        { value: "text", label: "Text output (Recommended)", description: "human-readable summary" },
+        { value: "json", label: "JSON output", description: "machine-readable verification payload" },
+      ],
+      { defaultIndex: 0 },
+    )
+    : null;
+  const outputAsJson = boolFromRaw(flags.json, false) || interactiveJsonChoice?.value === "json";
+
+  if (outputAsJson) {
     process.stdout.write(
       `${JSON.stringify({
         ok: overallOK,
@@ -1594,9 +1684,7 @@ async function runBotVerify(ui, flags, deps) {
 }
 
 async function runBotSetDefault(ui, flags, deps) {
-  const provider = String(flags.provider || "").trim()
-    ? requireDependency(deps, "normalizeBotProvider")(flags.provider)
-    : "telegram";
+  const provider = await selectProvider(ui, flags.provider, deps);
   if (provider !== "telegram") {
     throw new Error("bot set-default currently supports only --provider telegram");
   }
@@ -1609,6 +1697,16 @@ async function runBotSetDefault(ui, flags, deps) {
   if (!selected) {
     throw new Error("Telegram bot selector is required for set-default");
   }
+  if (!nonInteractive && !await promptConfirmChoice(ui, `Set "${selected.key}" as TELEGRAM_DEFAULT_BOT_KEY?`, {
+    confirmLabel: "Set default bot",
+    confirmDescription: "make this the default local Telegram bot entry",
+    cancelLabel: "Cancel",
+    cancelDescription: "leave the current default unchanged",
+    defaultValue: "confirm",
+  })) {
+    process.stdout.write("Cancelled.\n");
+    return;
+  }
   parsed.TELEGRAM_DEFAULT_BOT_KEY = selected.key;
   const filePath = writeProviderEnvState("telegram", parsed, deps);
   process.stdout.write(`Set TELEGRAM_DEFAULT_BOT_KEY=${selected.key} in ${filePath}\n`);

package/lib/selftest-bot-commands.mjs

@@ -45,6 +45,45 @@ function readJSON(rawText) {
   return JSON.parse(String(rawText || "").trim() || "{}");
 }
 
+function readTrailingJSON(rawText) {
+  const text = String(rawText || "");
+  const start = text.indexOf("{");
+  if (start < 0) {
+    return readJSON(text);
+  }
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (char === "\\") {
+        escaping = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "\"") {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return readJSON(text.slice(start, index + 1));
+      }
+    }
+  }
+  return readJSON(text.slice(start));
+}
+
 function createMockServer() {
   const serverBots = [
     {
@@ -237,11 +276,11 @@ export async function runSelftestBotCommands(push, deps) {
           "selftest-main-token",
           "y", // verify now
           "", // keep verified username
-          "3", // role profile: monitor
-          "2", // ai client: codex
-          "gpt-5-codex",
-          "2", // permission: read_only
-          "2", // reasoning: low
+          "", // keep role profile default from selected server role
+          "", // keep AI client default from role profile
+          "", // keep AI model default from role profile
+          "", // keep permission default from role profile
+          "", // keep reasoning default from role profile
           "y", // set as default
         ]),
       },
@@ -251,10 +290,12 @@ export async function runSelftestBotCommands(push, deps) {
       "bot_add_guided_creates_named_telegram_entry",
       String(addState.TELEGRAM_BOT_MAIN_TEST_SERVER_BOT_ID || "") === mock.bots[0].id
         && String(addState.TELEGRAM_BOT_MAIN_TEST_USERNAME || "").trim().toLowerCase() === "monitorselftestbot"
+        && String(addState.TELEGRAM_BOT_MAIN_TEST_ROLE_PROFILE || "") === "monitor"
         && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "") === "codex"
-        && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "") === "gpt-5-codex"
+        && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_PERMISSION_MODE || "") === "read_only"
+        && String(addState.TELEGRAM_BOT_MAIN_TEST_AI_REASONING_EFFORT || "") === "low"
         && String(addState.TELEGRAM_DEFAULT_BOT_KEY || "") === "main_test",
-      `default=${String(addState.TELEGRAM_DEFAULT_BOT_KEY || "")} client=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")} model=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "")}`,
+      `default=${String(addState.TELEGRAM_DEFAULT_BOT_KEY || "")} role=${String(addState.TELEGRAM_BOT_MAIN_TEST_ROLE_PROFILE || "")} client=${String(addState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")}`,
     );
 
     const showResult = await runCLI({
@@ -338,6 +379,50 @@ export async function runSelftestBotCommands(push, deps) {
       `client=${String(editedState.TELEGRAM_BOT_MAIN_TEST_AI_CLIENT || "")} model=${String(editedState.TELEGRAM_BOT_MAIN_TEST_AI_MODEL || "")}`,
     );
 
+    await runCLI({
+      cliPath,
+      args: ["bot", "set-default"],
+      env: {
+        ...env,
+        METHEUS_SCRIPTED_PROMPT_ANSWERS: JSON.stringify([
+          "1", // provider: telegram
+          "1", // bot entry: main_test
+          "1", // confirm set default
+        ]),
+      },
+    });
+    const guidedDefaultState = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
+    push(
+      "bot_set_default_guided_selects_entry",
+      String(guidedDefaultState.TELEGRAM_DEFAULT_BOT_KEY || "") === "main_test",
+      `default=${String(guidedDefaultState.TELEGRAM_DEFAULT_BOT_KEY || "")}`,
+    );
+
+    const guidedVerifyResult = await runCLI({
+      cliPath,
+      args: [
+        "bot", "verify",
+        "--base-url", baseURL,
+        "--timeout-seconds", "5",
+      ],
+      env: {
+        ...env,
+        METHEUS_SCRIPTED_PROMPT_ANSWERS: JSON.stringify([
+          "1", // provider: telegram
+          "1", // bot entry: main_test
+          "2", // output format: json
+        ]),
+      },
+    });
+    const guidedVerifyPayload = readTrailingJSON(guidedVerifyResult.stdout);
+    push(
+      "bot_verify_guided_can_emit_json",
+      guidedVerifyPayload.ok === true
+        && safeObject(guidedVerifyPayload.serverBinding).ok === true
+        && String(guidedVerifyPayload.client || "") === "claude",
+      `verify=${String(guidedVerifyPayload.ok)} server=${String(safeObject(guidedVerifyPayload.serverBinding).detail || "")}`,
+    );
+
     await runCLI({
       cliPath,
       args: [
@@ -435,16 +520,49 @@ export async function runSelftestBotCommands(push, deps) {
       `client=${String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_CLIENT || "")} model=${String(aliasAddState.TELEGRAM_BOT_EXPLICIT_TEST_AI_MODEL || "")}`,
     );
 
+    const guidedRemoveBeforeList = await runCLI({
+      cliPath,
+      args: [
+        "bot", "list",
+        "--provider", "telegram",
+        "--json", "true",
+      ],
+      env,
+    });
+    const guidedRemoveBeforePayload = ensureArray(readJSON(guidedRemoveBeforeList.stdout));
+    const guidedRemoveBeforeEntry = safeObject(guidedRemoveBeforePayload[0]);
+    const guidedRemoveEntries = ensureArray(guidedRemoveBeforeEntry.entries);
+    const explicitEntryIndex = guidedRemoveEntries.findIndex((entry) => String(safeObject(entry).key || "") === "explicit_test");
+
     await runCLI({
+      cliPath,
+      args: ["bot", "remove"],
+      env: {
+        ...env,
+        METHEUS_SCRIPTED_PROMPT_ANSWERS: JSON.stringify([
+          "1", // provider: telegram
+          String(explicitEntryIndex + 1), // bot entry: explicit_test
+          "1", // confirm remove
+        ]),
+      },
+    });
+    const guidedRemoveList = await runCLI({
       cliPath,
       args: [
-        "bot", "remove",
+        "bot", "list",
         "--provider", "telegram",
-        "--bot-key", "explicit_test",
-        "--non-interactive", "true",
+        "--json", "true",
       ],
       env,
     });
+    const guidedRemovePayload = ensureArray(readJSON(guidedRemoveList.stdout));
+    const guidedRemoveEntry = safeObject(guidedRemovePayload[0]);
+    push(
+      "bot_remove_guided_deletes_selected_entry",
+      explicitEntryIndex >= 0
+        && ensureArray(guidedRemoveEntry.entries).length === 0,
+      `entries=${String(ensureArray(guidedRemoveEntry.entries).length)} selected=${String(explicitEntryIndex + 1)}`,
+    );
 
     const migratedEnv = parseSimpleEnvText(fs.readFileSync(telegramEnvPath, "utf8"));
     migratedEnv.TELEGRAM_BOT_TOKEN = "legacy-selftest-token";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.65",
+  "version": "0.2.67",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [