kiro-telegram-bot 1.5.1

package/src/bot/chat-controller.ts

@@ -0,0 +1,251 @@
+/**
+ * ChatController — manages the set of Kiro sessions a single Telegram chat is
+ * controlling, with exactly one "foreground" session streaming live. Other
+ * (background) sessions keep running quietly; their output lands in the
+ * session's .jsonl and is replayed as "unread" when you switch to them.
+ */
+import { basename } from "node:path";
+import type { Api } from "grammy";
+import type { AcpClient } from "../acp/client.js";
+import type { SettingsStore } from "../app/settings-store.js";
+import type { AppConfig } from "../config.js";
+import { jsonlSize, readEntriesFrom, readHistory } from "../sessions/history.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { HistoryEntry } from "../sessions/types.js";
+import { SessionRuntime } from "./session-runtime.js";
+
+export interface RunningSession {
+  sessionId?: string;
+  projectName: string;
+  busy: boolean;
+  foreground: boolean;
+  unread: number;
+}
+
+export interface SwitchResult {
+  rt: SessionRuntime;
+  sessionId?: string;
+  projectName?: string;
+  busy: boolean;
+  unread: HistoryEntry[];
+  firstView: boolean;
+  alreadyForeground: boolean;
+}
+
+export class ChatController {
+  private readonly runtimes: SessionRuntime[] = [];
+  private fg: SessionRuntime | undefined;
+  private readonly lastRead = new Map<string, number>();
+  private restored = false;
+
+  constructor(
+    private readonly api: Api,
+    private readonly chatId: number,
+    private readonly acp: AcpClient,
+    private readonly cfg: AppConfig,
+    private readonly settings: SettingsStore,
+    private readonly store: SessionStore,
+    private readonly refresh: (chatId: number) => void,
+    private readonly notifyActivity: (busy: boolean) => void,
+  ) {}
+
+  /** The current foreground runtime (created/restored lazily). */
+  foreground(): SessionRuntime {
+    this.ensureRestored();
+    if (!this.fg) {
+      const s = this.settings.get(this.chatId);
+      const rt = this.create({ cwd: s.projectPath ?? this.cfg.workspace, projectName: s.projectName, sessionId: s.sessionId });
+      this.runtimes.push(rt);
+      this.fg = rt;
+    }
+    return this.fg;
+  }
+
+  /** List the controlled sessions (for /running). */
+  list(): RunningSession[] {
+    this.ensureRestored();
+    return this.runtimes.map((rt) => ({
+      sessionId: rt.sessionId,
+      projectName: rt.projectName ?? basename(rt.cwd),
+      busy: rt.isBusy,
+      foreground: rt.isForeground,
+      unread: this.unreadCount(rt),
+    }));
+  }
+
+  /** Start a brand-new session and bring it to the foreground. */
+  async addNew(cwd: string, projectName?: string): Promise<SessionRuntime> {
+    this.ensureRestored();
+    await this.background(this.fg);
+    const rt = this.create({ cwd, projectName });
+    this.runtimes.push(rt);
+    this.fg = rt;
+    await rt.startNewSession(cwd, projectName);
+    this.markSeen(rt);
+    this.persist();
+    return rt;
+  }
+
+  /**
+   * Connect to a session with resume-or-fork semantics (used by /sessions),
+   * adding it as a controlled session and bringing it to the foreground.
+   */
+  async addAttach(
+    sessionId: string,
+    cwd: string,
+    projectName: string | undefined,
+    priorEntries: HistoryEntry[],
+  ): Promise<{ rt: SessionRuntime; result: "resumed" | "forked"; alreadyControlled: boolean }> {
+    this.ensureRestored();
+    if (this.runtimes.some((r) => r.sessionId === sessionId)) {
+      const sw = await this.switchTo(sessionId);
+      return { rt: sw!.rt, result: "resumed", alreadyControlled: true };
+    }
+    await this.background(this.fg);
+    const rt = this.create({ cwd, projectName, sessionId });
+    this.runtimes.push(rt);
+    this.fg = rt;
+    const result = await rt.attach(sessionId, cwd, projectName, priorEntries);
+    this.markSeen(rt);
+    this.persist();
+    return { rt, result, alreadyControlled: false };
+  }
+
+  /** Connect to an existing session: switch if already controlled, else add it. */
+  async addResume(sessionId: string, cwd: string, projectName?: string): Promise<SwitchResult> {
+    this.ensureRestored();
+    if (this.runtimes.some((r) => r.sessionId === sessionId)) {
+      return (await this.switchTo(sessionId))!;
+    }
+    await this.background(this.fg);
+    const rt = this.create({ cwd, projectName, sessionId });
+    this.runtimes.push(rt);
+    this.fg = rt;
+    await rt.prepare().catch(() => {});
+    const path = this.store.jsonlPath(sessionId);
+    const unread = readHistory(path, 12);
+    this.lastRead.set(sessionId, jsonlSize(path));
+    this.persist();
+    return { rt, sessionId, projectName, busy: rt.isBusy, unread, firstView: true, alreadyForeground: false };
+  }
+
+  /** Switch the foreground to an already-controlled session. */
+  async switchTo(sessionId: string): Promise<SwitchResult | undefined> {
+    this.ensureRestored();
+    const rt = this.runtimes.find((r) => r.sessionId === sessionId);
+    if (!rt) return undefined;
+    if (rt === this.fg) {
+      return { rt, sessionId, projectName: rt.projectName, busy: rt.isBusy, unread: [], firstView: false, alreadyForeground: true };
+    }
+    await this.background(this.fg);
+    this.fg = rt;
+    await rt.setForeground(true);
+    await rt.prepare().catch(() => {});
+
+    const path = this.store.jsonlPath(sessionId);
+    const seen = this.lastRead.get(sessionId);
+    let unread: HistoryEntry[] = [];
+    let firstView = false;
+    if (seen !== undefined) {
+      unread = readEntriesFrom(path, seen).entries;
+    } else {
+      unread = readHistory(path, 12);
+      firstView = true;
+    }
+    this.lastRead.set(sessionId, jsonlSize(path));
+    // No tail-watch here: setForeground(true) above already resumed RICH live
+    // streaming for the in-flight turn via the agent's own session/update
+    // events. Tailing the .jsonl too would double-render every update.
+    this.persist();
+    return { rt, sessionId, projectName: rt.projectName, busy: rt.isBusy, unread, firstView, alreadyForeground: false };
+  }
+
+  /** Stop controlling a session (does not kill it). */
+  async close(sessionId: string): Promise<boolean> {
+    this.ensureRestored();
+    const idx = this.runtimes.findIndex((r) => r.sessionId === sessionId);
+    if (idx === -1) return false;
+    const rt = this.runtimes[idx]!;
+    rt.dispose();
+    this.runtimes.splice(idx, 1);
+    this.lastRead.delete(sessionId);
+    if (this.fg === rt) {
+      this.fg = this.runtimes[0];
+      if (this.fg) await this.fg.setForeground(true);
+    }
+    this.persist();
+    return true;
+  }
+
+  count(): number {
+    this.ensureRestored();
+    return this.runtimes.length;
+  }
+
+  findBySession(sessionId: string): boolean {
+    return this.runtimes.some((r) => r.sessionId === sessionId);
+  }
+
+  dispose(): void {
+    for (const rt of this.runtimes) rt.dispose();
+    this.runtimes.length = 0;
+    this.fg = undefined;
+  }
+
+  // ── internals ──────────────────────────────────────────────────────────────
+
+  private ensureRestored(): void {
+    if (this.restored) return;
+    this.restored = true;
+    const s = this.settings.get(this.chatId);
+    for (const cs of s.controlledSessions ?? []) {
+      if (!cs.sessionId) continue;
+      this.runtimes.push(this.create({ cwd: cs.projectPath, projectName: cs.projectName, sessionId: cs.sessionId }));
+    }
+    if (this.runtimes.length > 0) {
+      const fg = this.runtimes.find((r) => r.sessionId === s.foregroundSessionId) ?? this.runtimes[0]!;
+      for (const r of this.runtimes) void r.setForeground(r === fg);
+      this.fg = fg;
+    }
+  }
+
+  private create(init: { cwd: string; projectName?: string; sessionId?: string }): SessionRuntime {
+    const rt = new SessionRuntime(this.api, this.chatId, this.acp, this.cfg, this.settings, init);
+    rt.onStateChange = () => this.refresh(this.chatId);
+    rt.onActivity = (busy) => this.notifyActivity(busy);
+    return rt;
+  }
+
+  private async background(rt: SessionRuntime | undefined): Promise<void> {
+    if (!rt) return;
+    this.markSeen(rt);
+    await rt.setForeground(false);
+  }
+
+  private markSeen(rt: SessionRuntime): void {
+    if (rt.sessionId) this.lastRead.set(rt.sessionId, jsonlSize(this.store.jsonlPath(rt.sessionId)));
+  }
+
+  private unreadCount(rt: SessionRuntime): number {
+    if (!rt.sessionId || rt.isForeground) return 0;
+    const seen = this.lastRead.get(rt.sessionId);
+    if (seen === undefined) return 0;
+    return readEntriesFrom(this.store.jsonlPath(rt.sessionId), seen).entries.length;
+  }
+
+  private persist(): void {
+    const controlled = this.runtimes
+      .filter((r) => r.sessionId)
+      .map((r) => ({ sessionId: r.sessionId, projectPath: r.cwd, projectName: r.projectName }));
+    this.settings.update(this.chatId, {
+      controlledSessions: controlled,
+      foregroundSessionId: this.fg?.sessionId,
+      // Keep the single-session restore fields aligned with the foreground so
+      // the pinned status panel and a fresh restore never show a project that
+      // belongs to a different (previously-foreground) session.
+      sessionId: this.fg?.sessionId,
+      projectPath: this.fg?.cwd,
+      projectName: this.fg?.projectName,
+    });
+  }
+}

package/src/bot/commands.ts

@@ -0,0 +1,48 @@
+/**
+ * Bot command definitions (for the Telegram command menu) and help text.
+ */
+export const COMMANDS: { command: string; description: string }[] = [
+  { command: "start", description: "Welcome, menu & status panel" },
+  { command: "menu", description: "Show the menu keyboard" },
+  { command: "projects", description: "Projects: list / search <q> / new <name>" },
+  { command: "sessions", description: "List/resume sessions (active first) \u00b7 /sessions <q>" },
+  { command: "active", description: "Sessions running now on the PC" },
+  { command: "running", description: "Sessions this chat controls \u2014 switch between them" },
+  { command: "killall", description: "Kill all active sessions on the PC" },
+  { command: "mcp", description: "Inspect & toggle MCP servers \u00b7 health-check" },
+  { command: "tasks", description: "Manage scheduled tasks" },
+  { command: "newtask", description: "Create a scheduled task" },
+  { command: "history", description: "Show recent conversation history" },
+  { command: "new", description: "Start a fresh session here" },
+  { command: "status", description: "Current session, project & queue" },
+  { command: "usage", description: "Account & context usage" },
+  { command: "btw", description: "Queue a follow-up: /btw <text>" },
+  { command: "flush", description: "Send queued follow-ups now" },
+  { command: "queue", description: "Show queued follow-ups" },
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "unwatch", description: "Stop following a live session" },
+  { command: "model", description: "Switch model: /model <id>" },
+  { command: "restart", description: "Restart the Kiro agent" },
+  { command: "help", description: "Show help" },
+];
+
+export const HELP_TEXT = [
+  "\u{1F916} Kiro Telegram Bot",
+  "Drive Kiro CLI from your phone \u2014 projects, resume, live sessions, diffs.",
+  "",
+  "HOW IT WORKS",
+  "\u2022 Just send a message to chat with Kiro in the current project.",
+  "\u2022 While Kiro is working, anything you send is queued and runs",
+  "  automatically when the current turn finishes.",
+  "",
+  "COMMANDS",
+  "/projects \u2014 choose which folder Kiro works in",
+  "/sessions \u2014 resume one of your recent Kiro sessions",
+  "/active \u2014 attach to a session currently running on the PC",
+  "/history \u2014 show the latest messages of the current session",
+  "/new \u2014 start a brand-new session in the current project",
+  "/btw <text> \u2014 add a follow-up to run after the current task",
+  "/flush \u2014 run queued follow-ups immediately",
+  "/cancel \u2014 stop the current turn",
+  "/status \u2014 show session, project and queue size",
+].join("\n");

package/src/bot/deps.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared dependencies passed to all handlers, plus a small per-chat cache for
+ * mapping inline-keyboard buttons back to long values (project paths).
+ */
+import type { Api } from "grammy";
+import type { AcpClient } from "../acp/client.js";
+import type { SettingsStore } from "../app/settings-store.js";
+import type { AppConfig } from "../config.js";
+import type { SttService } from "../app/stt.js";
+import type { UsageService } from "../app/usage.js";
+import type { ProjectEntry, ProjectManager } from "../projects/manager.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { TaskRunner } from "../tasks/runner.js";
+import type { TaskStore } from "../tasks/store.js";
+import type { StatusPanel } from "./menu/status-panel.js";
+import type { RuntimeRegistry } from "./registry.js";
+import type { TaskWizard } from "./wizard/task-wizard.js";
+
+export interface BotDeps {
+  api: Api;
+  cfg: AppConfig;
+  acp: AcpClient;
+  registry: RuntimeRegistry;
+  store: SessionStore;
+  projects: ProjectManager;
+  menuCache: MenuCache;
+  settings: SettingsStore;
+  statusPanel: StatusPanel;
+  tasks: TaskStore;
+  taskRunner: TaskRunner;
+  wizard: TaskWizard;
+  stt: SttService;
+  usage: UsageService;
+}
+
+/** Caches the last project list shown per chat for callback resolution. */
+export class MenuCache {
+  private readonly projectLists = new Map<number, ProjectEntry[]>();
+
+  setProjects(chatId: number, list: ProjectEntry[]): void {
+    this.projectLists.set(chatId, list);
+  }
+
+  getProject(chatId: number, index: number): ProjectEntry | undefined {
+    return this.projectLists.get(chatId)?.[index];
+  }
+}

package/src/bot/handlers/control.ts

@@ -0,0 +1,94 @@
+/**
+ * Control commands: /start /help /status /new /cancel /btw /flush.
+ */
+import type { Bot } from "grammy";
+import { basename } from "node:path";
+import { textPrompt } from "../../app/types.js";
+import type { BotDeps } from "../deps.js";
+import { HELP_TEXT } from "../commands.js";
+import { compactKeyboard } from "../menu/keyboard.js";
+import { refreshMenu } from "../menu/refresh.js";
+import { openMainMenu } from "./menu.js";
+
+export function registerControl(bot: Bot, deps: BotDeps): void {
+  bot.command("start", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    const agent = deps.acp.agentInfo;
+    const lines = [
+      "\u{1F44B} Welcome! I bridge Telegram to Kiro CLI over ACP.",
+      agent?.name ? `Connected to ${agent.name} ${agent.version ?? ""}`.trim() : "",
+      "",
+      "Tap \u2630 Menu for everything. The pinned panel above always shows your",
+      "project, agent, reasoning and model. Just send a message to start.",
+    ].filter(Boolean);
+    await ctx.reply(lines.join("\n"), { reply_markup: compactKeyboard() });
+    await deps.statusPanel.refresh(ctx.chat.id);
+  });
+
+  bot.command("menu", async (ctx) => {
+    await openMainMenu(ctx, deps);
+    await deps.statusPanel.refresh(ctx.chat.id);
+  });
+
+  bot.command("help", async (ctx) => {
+    await ctx.reply(HELP_TEXT);
+  });
+
+  bot.command("status", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    const lines = [
+      "\u{1F4CA} Status",
+      `Project: ${rt.projectName ?? (basename(rt.cwd) || rt.cwd)}`,
+      `Folder: ${rt.cwd}`,
+      `Session: ${rt.sessionId ?? "(none yet)"}`,
+      `State: ${rt.isBusy ? "\u23F3 working" : "\u2705 idle"}`,
+      `Queued follow-ups: ${rt.queueLength}`,
+    ];
+    const subagents = deps.registry.subagentSummaryForChat(ctx.chat.id);
+    if (subagents) lines.push(`Subagents: ${subagents}`);
+    await ctx.reply(lines.join("\n"));
+  });
+
+  bot.command("new", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    try {
+      await deps.registry.controller(ctx.chat.id).addNew(rt.cwd, rt.projectName);
+      await refreshMenu(ctx, deps, `\u2728 New session started in ${rt.projectName ?? rt.cwd}`);
+    } catch (err) {
+      await ctx.reply(`\u274C Could not start session: ${(err as Error).message}`);
+    }
+  });
+
+  bot.command("cancel", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    const cancelled = await rt.cancel();
+    await ctx.reply(cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.");
+  });
+
+  bot.command("btw", async (ctx) => {
+    const text = (ctx.match || "").toString().trim();
+    if (!text) {
+      await ctx.reply("Usage: /btw <something to do after the current task>");
+      return;
+    }
+    const rt = deps.registry.get(ctx.chat.id);
+    rt.enqueue(textPrompt(text));
+    await ctx.reply(`\u{1F4E5} Queued (position ${rt.queueLength}). It'll run when the current task finishes.`);
+  });
+
+  bot.command("flush", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    if (rt.queueLength === 0) {
+      await ctx.reply("Queue is empty.");
+      return;
+    }
+    if (rt.isBusy) {
+      await ctx.reply(`\u23F3 ${rt.queueLength} queued \u2014 they'll run automatically when the current turn ends.`);
+      return;
+    }
+    // Idle: drain the queue by submitting an empty trigger that flushes.
+    await ctx.reply("\u25B6\uFE0F Running queued follow-ups\u2026");
+    const drained = rt.drainQueueToPrompt();
+    if (drained) await rt.submit(drained);
+  });
+}

package/src/bot/handlers/history.ts

@@ -0,0 +1,58 @@
+/**
+ * /history — show the latest messages of the current (or a chosen) session.
+ */
+import type { Bot } from "grammy";
+import { basename } from "node:path";
+import type { BotDeps } from "../deps.js";
+import { readHistory } from "../../sessions/history.js";
+import type { SessionMeta } from "../../sessions/types.js";
+import { sendMarkdownDoc } from "../telegram-io.js";
+
+const ENTRY_MAX = 700;
+const ROLE_ICON: Record<string, string> = {
+  user: "\u{1F464}",
+  assistant: "\u{1F916}",
+  tool: "\u{1F527}",
+  system: "\u2139\uFE0F",
+};
+
+export function registerHistory(bot: Bot, deps: BotDeps): void {
+  bot.command("history", async (ctx) => {
+    const rt = deps.registry.get(ctx.chat.id);
+    if (!rt.sessionId) {
+      await ctx.reply("No active session. Use /sessions or send a message first.");
+      return;
+    }
+    const meta = deps.store.get(rt.sessionId);
+    await showHistory(deps, ctx.chat.id, rt.sessionId, meta);
+  });
+}
+
+/** Render and send the recent history of a session. */
+export async function showHistory(
+  deps: BotDeps,
+  chatId: number,
+  sessionId: string,
+  meta?: SessionMeta,
+  count = 16,
+): Promise<void> {
+  const entries = readHistory(deps.store.jsonlPath(sessionId), count);
+  if (entries.length === 0) {
+    await deps.api.sendMessage(chatId, "No history found for this session yet.");
+    return;
+  }
+  const title = meta?.title || sessionId.slice(0, 8);
+  const proj = meta?.cwd ? basename(meta.cwd) : "";
+  const header = `\u{1F4DC} **History** \u2014 ${title}${proj ? ` (${proj})` : ""}`;
+
+  const body = entries
+    .map((e) => {
+      const icon = ROLE_ICON[e.role] ?? "\u2022";
+      let text = e.text.length > ENTRY_MAX ? e.text.slice(0, ENTRY_MAX) + " …" : e.text;
+      if (e.role === "tool" && e.tool) text = `\`${e.tool}\` ${text}`;
+      return `${icon} ${text}`;
+    })
+    .join("\n\n");
+
+  await sendMarkdownDoc(deps.api, chatId, `${header}\n\n${body}`);
+}

package/src/bot/handlers/kill.ts

@@ -0,0 +1,69 @@
+/**
+ * /killall — terminate all active Kiro sessions running on this PC (the ones
+ * holding a live session lock), excluding the bot's own agent process. Guarded
+ * by an inline confirmation since it kills processes.
+ */
+import { execFileSync } from "node:child_process";
+import { type Bot, type Context, InlineKeyboard } from "grammy";
+import { createLogger } from "../../logger.js";
+import type { SessionMeta } from "../../sessions/types.js";
+import type { BotDeps } from "../deps.js";
+
+const log = createLogger("killall");
+
+function targets(deps: BotDeps): SessionMeta[] {
+  const self = deps.acp.pid;
+  return deps.store.listActive().filter((s) => s.lockPid && s.lockPid !== self);
+}
+
+export async function showKillConfirm(ctx: Context, deps: BotDeps): Promise<void> {
+  const active = targets(deps);
+  if (active.length === 0) {
+    await ctx.reply("\u2705 No other active Kiro sessions to kill.");
+    return;
+  }
+  const list = active
+    .slice(0, 12)
+    .map((s) => `\u2022 ${s.title.slice(0, 40)} (pid ${s.lockPid})`)
+    .join("\n");
+  const kb = new InlineKeyboard()
+    .text(`\u{1F6D1} Kill ${active.length}`, "killall:confirm")
+    .text("Cancel", "killall:cancel");
+  await ctx.reply(
+    `\u{1F6D1} Kill ${active.length} active session(s)?\n${list}\n\n(The bot's own session is excluded.)`,
+    { reply_markup: kb },
+  );
+}
+
+export function registerKill(bot: Bot, deps: BotDeps): void {
+  bot.command("killall", (ctx) => showKillConfirm(ctx, deps));
+
+  bot.callbackQuery("killall:cancel", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    await ctx.editMessageText("Cancelled.").catch(() => {});
+  });
+
+  bot.callbackQuery("killall:confirm", async (ctx) => {
+    await ctx.answerCallbackQuery();
+    const active = targets(deps);
+    let killed = 0;
+    for (const s of active) {
+      if (s.lockPid && killPid(s.lockPid)) killed++;
+    }
+    await ctx.editMessageText(`\u{1F6D1} Killed ${killed} of ${active.length} active session(s).`).catch(() => {});
+  });
+}
+
+function killPid(pid: number): boolean {
+  try {
+    if (process.platform === "win32") {
+      execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+    } else {
+      process.kill(pid, "SIGKILL");
+    }
+    return true;
+  } catch (e) {
+    log.debug(`kill ${pid} failed:`, (e as Error).message);
+    return false;
+  }
+}