grok-telegram-bot 2.6.0 → 2.7.0

package/src/bot/bot.ts

@@ -44,6 +44,9 @@ import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
 import { registerVoice } from "./handlers/voice.js";
 import { registerForum } from "./handlers/forum.js";
+import { registerGrokSlash } from "./handlers/grok-slash.js";
+import { AskUserService } from "./ask-user-service.js";
+import { PlanExitService } from "./plan-exit-service.js";
 import { StatusPanel } from "./menu/status-panel.js";
 import { sendMarkdownDoc } from "./telegram-io.js";
 import { Ephemeral } from "./menu/ephemeral.js";
@@ -207,6 +210,18 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     onUnpinned: (chatId) => statusPanel.ensurePinned(chatId),
   });
   acp.permissionHandler = (p) => permissions.handle(p);
+
+  const planExit = new PlanExitService(bot.api, registry, cfg.autoApprovePlan, (chatId) =>
+    statusPanel.ensurePinned(chatId),
+  );
+  acp.planExitHandler = (params) => planExit.handle(params);
+
+  const askUser = new AskUserService(
+    bot.api,
+    registry,
+    cfg.autoApprovePlan && cfg.autoApprovePermissions,
+  );
+  acp.askUserHandler = (params) => askUser.handle(params);
   // /stop and /cancel must cancel pending interactive permissions for that
   // session only (ACP requires cancelled outcomes) — never kill the agent.
   acp.onSessionCancel = (sessionId) => {
@@ -252,6 +267,16 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     if (sid) await switchAndShow(ctx, deps, sid);
   });
 
+  bot.callbackQuery(/^planx:(\d+):(ok|chg|no)$/, async (ctx) => {
+    const toast = planExit.resolveChoice(ctx.match![1]!, ctx.match![2]!);
+    await ctx.answerCallbackQuery({ text: toast ?? "Expired" });
+  });
+
+  bot.callbackQuery(/^asku:(\d+):(opt|next|prev|skip)(?::(.*))?$/, async (ctx) => {
+    const toast = askUser.tap(ctx.match![1]!, ctx.match![2]!, ctx.match![3]);
+    await ctx.answerCallbackQuery({ text: toast ?? "Expired" });
+  });
+
   // Legacy complexity buttons (removed — agent decides; auto-plan if complex).
   bot.callbackQuery(/^cplx:(simple|complex)$/, async (ctx) => {
     await ctx.answerCallbackQuery({ text: "Complexity is automatic now" });
@@ -349,6 +374,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
 
   registerMenu(bot, deps); // persistent-keyboard buttons (hears)
   registerWizardInput(bot, deps); // wizard text input (before commands)
+  bot.on("message:text", async (ctx, next) => {
+    const text = ctx.message?.text ?? "";
+    if (!text || text.startsWith("/")) return next();
+    if (planExit.takeFeedback(ctx.chat.id, text)) return;
+    await next();
+  });
   if (forum) registerForum(bot, deps, forum);
   registerControl(bot, deps);
   registerProjects(bot, deps);
@@ -367,6 +398,7 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   registerPhotos(bot, deps); // photos & image documents
   registerDocuments(bot, deps); // non-image files (text inlined, binaries saved)
   registerVoice(bot, deps); // voice / audio -> transcription -> prompt
+  registerGrokSlash(bot, deps); // Grok Build /goal /plan /compact … + catch-all
   registerMessages(bot, deps); // catch-all text prompt — keep last
 
   bot.catch((err) => {

package/src/bot/commands.ts

@@ -5,8 +5,10 @@
  * a shorter list with cancel/menu first — reply keyboards are unreliable there.
  */
 
-/** Full command menu (private chats + default). Order = Telegram "/" menu order. */
-export const COMMANDS: { command: string; description: string }[] = [
+import { GROK_FORWARDED_COMMANDS } from "./handlers/grok-slash.js";
+
+/** Bot-local commands (not forwarded to Grok). Order = Telegram "/" menu order. */
+export const BOT_COMMANDS: { command: string; description: string }[] = [
   // Core control
   { command: "start", description: "Welcome, menu & status panel" },
   { command: "menu", description: "Open the menu" },
@@ -37,10 +39,17 @@ export const COMMANDS: { command: string; description: string }[] = [
   { command: "killall", description: "Kill all active sessions on the PC" },
   { command: "model", description: "Switch model: /model <id>" },
   { command: "restart", description: "Restart the Grok agent" },
+  { command: "sandbox", description: "Show / set Grok sandbox profile" },
   { command: "unwatch", description: "Stop following a live session" },
   { command: "help", description: "Show help" },
 ];
 
+/** Full Telegram menu: bot-local + Grok Build shell forwards (≤100). */
+export const COMMANDS: { command: string; description: string }[] = [
+  ...BOT_COMMANDS,
+  ...GROK_FORWARDED_COMMANDS.map(({ command, description }) => ({ command, description })),
+];
+
 /**
  * Group / forum command menu — keep short; cancel & menu first so topics can
  * stop a turn without the private reply-keyboard bar.
@@ -56,6 +65,9 @@ export const GROUP_COMMANDS: { command: string; description: string }[] = [
   { command: "btw", description: "Queue or run: /btw <text>" },
   { command: "flush", description: "Run queued follow-ups now" },
   { command: "model", description: "Switch model: /model <id>" },
+  { command: "goal", description: "Grok /goal — run until done" },
+  { command: "plan", description: "Grok /plan — enter plan mode" },
+  { command: "compact", description: "Grok /compact — compress context" },
   { command: "help", description: "Show help" },
 ];
 
@@ -91,4 +103,12 @@ export const HELP_TEXT = [
   "/flush \u2014 run queued follow-ups immediately",
   "/reauth \u2014 sign in to Grok",
   "/accounts \u2014 switch saved Grok accounts",
+  "/sandbox \u2014 show or set GROK_SANDBOX (needs /restart)",
+  "",
+  "GROK BUILD SLASH (forwarded into the active session)",
+  "/goal /plan /view_plan /compact /context /session_info",
+  "/deep_research /workflow /workflows /loop",
+  "/remember /memory /memory_flush /dream",
+  "Underscores map to hyphens (e.g. /view_plan \u2192 /view-plan).",
+  "Other non-bot Grok /commands and skills are also forwarded.",
 ].join("\n");

package/src/bot/handlers/grok-slash.ts

@@ -0,0 +1,336 @@
+/**
+ * Forward Grok Build slash commands (e.g. /goal, /plan, /compact) into the
+ * active ACP session. Grok shell builtins are parsed from the prompt text by
+ * slash_exec — they never reached the agent before because the Telegram message
+ * handler treated unknown "/…" lines as typos.
+ *
+ * Bot-local commands (projects, sessions, reauth, …) stay reserved and are
+ * handled by their own `bot.command` registrations. Name collisions use
+ * non-colliding Telegram aliases that still send the correct Grok slash line.
+ */
+import type { Bot, Context } from "grammy";
+import { textPrompt } from "../../app/types.js";
+import { createLogger } from "../../logger.js";
+import { isGeneralThread } from "../../forum/thread.js";
+import type { BotDeps } from "../deps.js";
+import { extractReplyContext } from "../reply-context.js";
+import { resolveScope } from "../scope.js";
+
+const log = createLogger("grok-slash");
+
+/**
+ * Telegram command names reserved by this bot (without leading slash).
+ * Must stay in sync with bot.command registrations / COMMANDS menu.
+ * Bare names in this set are NEVER stolen for Grok — use collision aliases.
+ */
+export const BOT_RESERVED_COMMANDS = new Set(
+  [
+    "start",
+    "menu",
+    "help",
+    "projects",
+    "project",
+    "sessions",
+    "active",
+    "running",
+    "killall",
+    "mcp",
+    "tasks",
+    "newtask",
+    "history",
+    "new",
+    "status",
+    "usage",
+    "btw",
+    "flush",
+    "queue",
+    "clearqueue",
+    "cancel",
+    "stop",
+    "unwatch",
+    "model",
+    "restart",
+    "sandbox",
+    "reauth",
+    "accounts",
+    "import",
+    "forum_setup",
+  ].map((c) => c.toLowerCase()),
+);
+
+/**
+ * Telegram command name (no slash, lowercase) → Grok shell command name (no slash).
+ * Covers hyphenated multi-word forms, documented Grok aliases, and collision aliases
+ * for bot-reserved bare names that still have distinct Grok builtins.
+ */
+export const GROK_SLASH_ALIASES: Readonly<Record<string, string>> = {
+  // Multi-word (Telegram underscore ↔ Grok hyphen)
+  view_plan: "view-plan",
+  show_plan: "view-plan",
+  plan_view: "view-plan",
+  deep_research: "deep-research",
+  always_approve: "always-approve",
+  session_info: "session-info",
+  imagine_video: "imagine-video",
+  config_agents: "config-agents",
+  release_notes: "release-notes",
+  import_claude: "import-claude",
+  compact_mode: "compact-mode",
+  vim_mode: "vim-mode",
+  agents_dashboard: "dashboard",
+  // No-underscore convenience forms
+  viewplan: "view-plan",
+  showplan: "view-plan",
+  planview: "view-plan",
+  deepresearch: "deep-research",
+  alwaysapprove: "always-approve",
+  sessioninfo: "session-info",
+  imaginevideo: "imagine-video",
+  configagents: "config-agents",
+  releasenotes: "release-notes",
+  importclaude: "import-claude",
+  // Documented Grok aliases
+  clear: "new",
+  undo: "rewind",
+  title: "rename",
+  m: "model",
+  mem: "memory",
+  cost: "usage",
+  agents: "config-agents",
+  howto: "docs",
+  guides: "docs",
+  changelog: "release-notes",
+  ml: "multiline",
+  t: "theme",
+  full: "fullscreen",
+  tour: "tutorial",
+  onboarding: "tutorial",
+  welcome: "home",
+  exit: "quit",
+  prefs: "settings",
+  preferences: "settings",
+  config: "settings",
+  terminal_setup: "doctor",
+  terminal_check: "doctor",
+  terminal_info: "doctor",
+  terminalsetup: "doctor",
+  terminalcheck: "doctor",
+  terminalinfo: "doctor",
+  // Bot name collisions → still send the Grok builtin
+  grok_new: "new",
+  session_new: "new",
+  grok_clear: "new",
+  memory_flush: "flush",
+  grok_flush: "flush",
+  grok_usage: "usage",
+  grok_cost: "usage",
+  grok_btw: "btw",
+  // session-info aliases when bare status/info are bot-reserved
+  grok_status: "session-info",
+  grok_info: "session-info",
+};
+
+/**
+ * Official shell builtins that are meaningful over ACP (not pure TUI/pager).
+ * Used for tests / inventory; menu may advertise a subset + collision aliases.
+ */
+export const GROK_SHELL_ACP_COMMANDS: readonly string[] = [
+  "new",
+  "compact",
+  "context",
+  "session-info",
+  "fork",
+  "rewind",
+  "copy",
+  "export",
+  "delete",
+  "rename",
+  "model",
+  "effort",
+  "always-approve",
+  "auto",
+  "plan",
+  "view-plan",
+  "memory",
+  "flush",
+  "dream",
+  "remember",
+  "hooks",
+  "plugins",
+  "marketplace",
+  "skills",
+  "imagine",
+  "imagine-video",
+  "loop",
+  "goal",
+  "deep-research",
+  "workflow",
+  "workflows",
+  "feedback",
+  "btw",
+  "mcps",
+  "doctor",
+  "release-notes",
+  "docs",
+  "import-claude",
+  "config-agents",
+  "personas",
+  "login",
+  "logout",
+  "usage",
+  "privacy",
+  "settings",
+];
+
+/** Grok Build slash commands we advertise in the Telegram menu (Telegram-safe names). */
+export const GROK_FORWARDED_COMMANDS: { command: string; description: string; grok: string }[] = [
+  // Session
+  { command: "compact", description: "Grok /compact — compress context", grok: "compact" },
+  { command: "context", description: "Grok /context — context window usage", grok: "context" },
+  { command: "session_info", description: "Grok /session-info", grok: "session-info" },
+  { command: "fork", description: "Grok /fork — branch session", grok: "fork" },
+  { command: "rewind", description: "Grok /rewind — undo last turns", grok: "rewind" },
+  { command: "copy", description: "Grok /copy — copy last response", grok: "copy" },
+  { command: "export", description: "Grok /export — export conversation", grok: "export" },
+  { command: "delete", description: "Grok /delete — delete session history", grok: "delete" },
+  { command: "rename", description: "Grok /rename <title>", grok: "rename" },
+  { command: "grok_new", description: "Grok /new — fresh session (CLI)", grok: "new" },
+  // Model / mode
+  { command: "effort", description: "Grok /effort low|medium|high|xhigh", grok: "effort" },
+  { command: "always_approve", description: "Grok /always-approve toggle", grok: "always-approve" },
+  { command: "auto", description: "Grok /auto — auto permission mode", grok: "auto" },
+  { command: "plan", description: "Grok /plan — enter plan mode", grok: "plan" },
+  { command: "view_plan", description: "Grok /view-plan — show saved plan", grok: "view-plan" },
+  // Memory
+  { command: "memory", description: "Grok /memory — browse memories", grok: "memory" },
+  { command: "memory_flush", description: "Grok /flush — save session to memory", grok: "flush" },
+  { command: "dream", description: "Grok /dream — consolidate memory", grok: "dream" },
+  { command: "remember", description: "Grok /remember <note>", grok: "remember" },
+  // Extensions
+  { command: "hooks", description: "Grok /hooks — hooks panel", grok: "hooks" },
+  { command: "plugins", description: "Grok /plugins — plugins panel", grok: "plugins" },
+  { command: "marketplace", description: "Grok /marketplace — plugin marketplace", grok: "marketplace" },
+  { command: "skills", description: "Grok /skills — skills panel", grok: "skills" },
+  // Media
+  { command: "imagine", description: "Grok /imagine <description>", grok: "imagine" },
+  { command: "imagine_video", description: "Grok /imagine-video <description>", grok: "imagine-video" },
+  // Scheduling / workflows / goals
+  { command: "loop", description: "Grok /loop [interval] <prompt>", grok: "loop" },
+  { command: "goal", description: "Grok /goal — set/status/pause/resume/clear", grok: "goal" },
+  { command: "deep_research", description: "Grok /deep-research <query>", grok: "deep-research" },
+  { command: "workflow", description: "Grok /workflow — run/manage workflow", grok: "workflow" },
+  { command: "workflows", description: "Grok /workflows — workflow dashboard", grok: "workflows" },
+  // Other
+  { command: "feedback", description: "Grok /feedback [message]", grok: "feedback" },
+  { command: "grok_btw", description: "Grok /btw — aside without interrupting", grok: "btw" },
+  { command: "mcps", description: "Grok /mcps — MCP servers modal", grok: "mcps" },
+  { command: "doctor", description: "Grok /doctor — session diagnostics", grok: "doctor" },
+  { command: "release_notes", description: "Grok /release-notes", grok: "release-notes" },
+  { command: "docs", description: "Grok /docs — how-to guides", grok: "docs" },
+  { command: "import_claude", description: "Grok /import-claude", grok: "import-claude" },
+  { command: "config_agents", description: "Grok /config-agents — agent defs", grok: "config-agents" },
+  { command: "personas", description: "Grok /personas — manage personas", grok: "personas" },
+  { command: "login", description: "Grok /login — re-auth in session", grok: "login" },
+  { command: "logout", description: "Grok /logout", grok: "logout" },
+  { command: "grok_usage", description: "Grok /usage — credit/billing", grok: "usage" },
+  { command: "privacy", description: "Grok /privacy — data/retention", grok: "privacy" },
+  { command: "settings", description: "Grok /settings — config modal", grok: "settings" },
+];
+
+/** Resolve a Telegram command token (no slash) to a Grok shell command name. */
+export function resolveGrokCommandName(telegramName: string): string {
+  const name = telegramName.toLowerCase();
+  const fromAlias = GROK_SLASH_ALIASES[name];
+  if (fromAlias) return fromAlias;
+  const fromMenu = GROK_FORWARDED_COMMANDS.find((c) => c.command === name);
+  if (fromMenu) return fromMenu.grok;
+  // underscore → hyphen for multi-word Grok commands (deep_research → deep-research)
+  return name.replace(/_/g, "-");
+}
+
+/** True when a bare slash line should be forwarded to Grok (not a bot command). */
+export function shouldForwardSlashToGrok(text: string): boolean {
+  const t = text.trim();
+  if (!t.startsWith("/") || t.includes("\n")) return false;
+  // /cmd@botname args
+  const m = t.match(/^\/([A-Za-z0-9_]+)(?:@\w+)?(?:\s|$)/);
+  if (!m) return false;
+  const name = m[1]!.toLowerCase();
+  if (BOT_RESERVED_COMMANDS.has(name)) return false;
+  return true;
+}
+
+/** Normalize Telegram `/view_plan foo` → Grok `/view-plan foo`. */
+export function toGrokSlashLine(text: string): string {
+  const t = text.trim();
+  const m = t.match(/^\/([A-Za-z0-9_]+)(@\w+)?([\s\S]*)$/);
+  if (!m) return t;
+  const rest = m[3] ?? "";
+  const name = resolveGrokCommandName(m[1]!);
+  return `/${name}${rest}`;
+}
+
+export async function submitGrokSlash(ctx: Context, deps: BotDeps, line: string): Promise<void> {
+  if (!ctx.chat) return;
+  const grokLine = toGrokSlashLine(line);
+  const scope = resolveScope(ctx, deps);
+  const extra: Record<string, unknown> = { parse_mode: "Markdown", ...scope.threadExtra };
+  if (scope.isForum && isGeneralThread(scope.threadId) && /^\/goal(?:\s|$)/i.test(grokLine)) {
+    await ctx.reply(
+      "Use /goal in a **project topic** or **AI Chat**, not in General \\(manager\\).",
+      extra,
+    );
+    return;
+  }
+  const rt = scope.rt;
+  try {
+    // Prefer dedicated ACP command RPC when the agent supports it; fall back to
+    // session/prompt (Grok slash_exec parses leading / in the prompt).
+    if (rt.sessionId) {
+      try {
+        await deps.acp.executeCommand(rt.sessionId, grokLine);
+        await ctx.reply(`\u25B6\uFE0F Sent to Grok: \`${grokLine}\``, extra);
+        return;
+      } catch (err) {
+        log.debug(
+          `executeCommand failed for ${grokLine}: ${(err as Error).message}; falling back to prompt`,
+        );
+      }
+    }
+    const outcome = await rt.submit(
+      textPrompt(grokLine, ctx.message?.message_id, extractReplyContext(ctx), {
+        skipSelfRecheck: true,
+        rawSlashCommand: true,
+      }),
+    );
+    if (outcome === "queued") {
+      await ctx.reply(
+        `\u{1F4E5} Queued (position ${rt.queueLength}): \`${grokLine}\` \u2014 runs after the current turn.`,
+        extra,
+      );
+    } else {
+      await ctx.reply(`\u25B6\uFE0F Running \`${grokLine}\`\u2026`, extra);
+    }
+  } catch (err) {
+    log.warn(`grok slash failed: ${(err as Error).message}`);
+    await ctx.reply(`\u274C Could not run \`${grokLine}\`: ${(err as Error).message}`, extra);
+  }
+}
+
+export function registerGrokSlash(bot: Bot, deps: BotDeps): void {
+  // Explicit Telegram commands for advertised Grok builtins (appear in menu).
+  for (const def of GROK_FORWARDED_COMMANDS) {
+    if (BOT_RESERVED_COMMANDS.has(def.command)) continue;
+    bot.command(def.command, async (ctx) => {
+      const args = (ctx.match || "").toString();
+      const line = args ? `/${def.command} ${args}` : `/${def.command}`;
+      await submitGrokSlash(ctx, deps, line);
+    });
+  }
+  // Catch-all for other Grok / skills slashes not in the menu.
+  bot.on("message:text", async (ctx, next) => {
+    const text = ctx.message?.text ?? "";
+    if (!shouldForwardSlashToGrok(text)) return next();
+    await submitGrokSlash(ctx, deps, text);
+  });
+}

package/src/bot/handlers/system.ts

@@ -1,9 +1,14 @@
 /**
- * System commands: /queue /clearqueue /model /restart.
+ * System commands: /queue /clearqueue /model /restart /sandbox.
  */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import type { Bot } from "grammy";
+import { InlineKeyboard } from "grammy";
+import { ENV_PATH } from "../../config.js";
 import type { BotDeps } from "../deps.js";
 
+const SANDBOX_PROFILES = ["workspace-safe", "workspace", "strict", "read-only", "off"] as const;
+
 export function registerSystem(bot: Bot, deps: BotDeps): void {
   bot.command("queue", async (ctx) => {
     const rt = deps.registry.get(ctx.chat.id);
@@ -48,4 +53,61 @@ export function registerSystem(bot: Bot, deps: BotDeps): void {
       await ctx.reply(`\u274C Restart failed: ${(err as Error).message}`);
     }
   });
+
+  bot.command("sandbox", async (ctx) => {
+    const arg = (ctx.match || "").toString().trim();
+    const current = deps.cfg.sandboxProfile || process.env.GROK_SANDBOX || "(from ~/.grok/config.toml)";
+    if (!arg) {
+      const kb = new InlineKeyboard();
+      for (const p of SANDBOX_PROFILES) kb.text(p, `sbx:${p}`).row();
+      await ctx.reply(
+        `\u{1F6E1} Sandbox profile now: ${current}\n` +
+          `Grok reads GROK_SANDBOX. Pick one, then /restart.\n` +
+          `Or: /sandbox workspace-safe`,
+        { reply_markup: kb },
+      );
+      return;
+    }
+    if (!(SANDBOX_PROFILES as readonly string[]).includes(arg)) {
+      await ctx.reply(`Unknown profile. Use: ${SANDBOX_PROFILES.join(", ")}`);
+      return;
+    }
+    try {
+      upsertEnv("GROK_SANDBOX", arg);
+      deps.cfg.sandboxProfile = arg;
+      process.env.GROK_SANDBOX = arg;
+      deps.acp.setAgentOptions({ sandboxProfile: arg });
+      await ctx.reply(`\u2705 GROK_SANDBOX=${arg} written. Send /restart to apply.`);
+    } catch (e) {
+      await ctx.reply(`\u274C Could not write .env: ${(e as Error).message}`);
+    }
+  });
+
+  bot.callbackQuery(/^sbx:([\w-]+)$/, async (ctx) => {
+    const profile = ctx.match![1]!;
+    if (!(SANDBOX_PROFILES as readonly string[]).includes(profile)) {
+      await ctx.answerCallbackQuery({ text: "Unknown profile" });
+      return;
+    }
+    try {
+      upsertEnv("GROK_SANDBOX", profile);
+      deps.cfg.sandboxProfile = profile;
+      process.env.GROK_SANDBOX = profile;
+      deps.acp.setAgentOptions({ sandboxProfile: profile });
+      await ctx.answerCallbackQuery({ text: profile });
+      await ctx.editMessageText(`\u2705 GROK_SANDBOX=${profile}. Send /restart to apply.`).catch(() => {});
+    } catch (e) {
+      await ctx.answerCallbackQuery({ text: (e as Error).message.slice(0, 40) });
+    }
+  });
+}
+
+/** Set KEY=value in the instance .env without dumping secrets. */
+function upsertEnv(key: string, value: string): void {
+  if (!existsSync(ENV_PATH)) throw new Error(".env not found");
+  let body = readFileSync(ENV_PATH, "utf-8");
+  const re = new RegExp(`^${key}=.*$`, "m");
+  if (re.test(body)) body = body.replace(re, `${key}=${value}`);
+  else body = body.replace(/\s*$/, `\n${key}=${value}\n`);
+  writeFileSync(ENV_PATH, body, "utf-8");
 }