kiro-telegram-bot 1.5.1

package/src/service/windows.ts

@@ -0,0 +1,103 @@
+/**
+ * Windows service controller — runs the bot at logon via a hidden Scheduled
+ * Task. A small .vbs launcher starts node with no console window; the app logs
+ * to a file. Stop precisely targets our node process by command line.
+ */
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { runSafe } from "./platform.js";
+import type { LaunchSpec, ServiceController, ServiceResult } from "./types.js";
+
+const TASK = "KiroTelegramBot";
+
+export const windowsController: ServiceController = {
+  platform: "windows",
+
+  async install(spec) {
+    mkdirSync(spec.logsDir, { recursive: true });
+    const vbs = join(spec.cwd, "run-service.vbs");
+    writeFileSync(vbs, vbsLauncher(spec), "utf-8");
+
+    runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]); // replace if present
+    const res = runSafe("schtasks", [
+      "/Create",
+      "/F",
+      "/SC",
+      "ONLOGON",
+      "/TN",
+      TASK,
+      "/TR",
+      `wscript.exe "${vbs}"`,
+    ]);
+    if (!res.ok) return fail(`schtasks create failed: ${res.out}`);
+    runSafe("schtasks", ["/Run", "/TN", TASK]);
+    return ok(`Installed scheduled task "${TASK}" (starts at logon) and launched it.`);
+  },
+
+  async uninstall(spec) {
+    await this.stop(spec);
+    const res = runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]);
+    rmSync(join(spec.cwd, "run-service.vbs"), { force: true });
+    return res.ok ? ok(`Removed scheduled task "${TASK}".`) : fail(res.out);
+  },
+
+  async start() {
+    const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
+    return res.ok ? ok("Started.") : fail(res.out);
+  },
+
+  async stop(spec) {
+    runSafe("schtasks", ["/End", "/TN", TASK]);
+    const res = runSafe("powershell", ["-NoProfile", "-Command", killScript(entryOf(spec))]);
+    return ok(`Stopped. ${res.out.trim()}`);
+  },
+
+  async status(spec) {
+    const task = runSafe("schtasks", ["/Query", "/TN", TASK, "/FO", "LIST"]);
+    const proc = runSafe("powershell", ["-NoProfile", "-Command", countScript(entryOf(spec))]);
+    const running = proc.ok && /[1-9]\d*/.test(proc.out.trim());
+    const installed = task.ok;
+    return ok(
+      `Installed: ${installed ? "yes" : "no"} | Running: ${running ? "yes" : "no"}\n` +
+        (installed ? task.out.trim() : "Task not found."),
+    );
+  },
+};
+
+/** The bot entry file — unique enough to identify the bot process. It may be
+ *  followed by trailing args (e.g. `--instance <dir>`), so find it explicitly. */
+function entryOf(spec: LaunchSpec): string {
+  return (
+    spec.args.find((a) => a.endsWith("index.ts")) ?? spec.args[spec.args.length - 1] ?? spec.cwd
+  );
+}
+
+function vbsLauncher(spec: LaunchSpec): string {
+  const cmd = `""${spec.nodePath}"" ${spec.args.map((a) => `""${a}""`).join(" ")}`;
+  return [
+    'Set sh = CreateObject("WScript.Shell")',
+    `sh.CurrentDirectory = "${spec.cwd}"`,
+    `sh.Run "${cmd}", 0, False`,
+  ].join("\r\n");
+}
+
+function killScript(entry: string): string {
+  const safe = entry.replace(/'/g, "''");
+  return [
+    `$p = Get-CimInstance Win32_Process -Filter "Name='node.exe'" | Where-Object { $_.CommandLine -like '*${safe}*' };`,
+    `$p | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue };`,
+    `"killed " + (@($p).Count)`,
+  ].join(" ");
+}
+
+function countScript(entry: string): string {
+  const safe = entry.replace(/'/g, "''");
+  return `@(Get-CimInstance Win32_Process -Filter "Name='node.exe'" | Where-Object { $_.CommandLine -like '*${safe}*' }).Count`;
+}
+
+function ok(message: string): ServiceResult {
+  return { ok: true, message };
+}
+function fail(message: string): ServiceResult {
+  return { ok: false, message };
+}

package/src/sessions/history.ts

@@ -0,0 +1,181 @@
+/**
+ * History parser — turns a session's .jsonl event log into readable entries.
+ * Reads only the tail of large logs to stay fast.
+ */
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import type { HistoryEntry, HistoryRole } from "./types.js";
+
+const TAIL_WINDOWS = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024]; // grow until entries found
+
+interface RawEvent {
+  kind?: string;
+  data?: {
+    content?: Array<{ kind?: string; data?: unknown; text?: unknown }>;
+    meta?: { timestamp?: number };
+    name?: string;
+    tool_name?: string;
+  };
+}
+
+/** Parse the most recent `maxEntries` history entries from a session log. */
+export function readHistory(jsonlPath: string, maxEntries = 20): HistoryEntry[] {
+  for (const window of TAIL_WINDOWS) {
+    const entries = parseTail(jsonlPath, window, maxEntries);
+    if (entries.length > 0) return entries;
+  }
+  return [];
+}
+
+/** Current byte size of a session log (0 if missing). */
+export function jsonlSize(jsonlPath: string): number {
+  try {
+    return statSync(jsonlPath).size;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Read the entries appended after `fromByte` (the "unread" since last seen).
+ * Returns the parsed entries and the new end-of-file byte offset. Kiro appends
+ * whole newline-terminated JSON objects, so `fromByte` is always a line boundary.
+ */
+export function readEntriesFrom(jsonlPath: string, fromByte: number): { entries: HistoryEntry[]; size: number } {
+  const size = jsonlSize(jsonlPath);
+  if (size <= fromByte || size === 0) return { entries: [], size };
+  const length = size - fromByte;
+  const fd = openSync(jsonlPath, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    readSync(fd, buf, 0, length, fromByte);
+    const lines = buf.toString("utf-8").split("\n").filter((l) => l.trim().length > 0);
+    const entries: HistoryEntry[] = [];
+    for (const line of lines) {
+      const e = parseEventLine(line);
+      if (e) entries.push(e);
+    }
+    return { entries, size };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function parseTail(jsonlPath: string, window: number, maxEntries: number): HistoryEntry[] {
+  const text = readTail(jsonlPath, window);
+  if (!text) return [];
+
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  const entries: HistoryEntry[] = [];
+
+  for (const line of lines) {
+    const entry = parseEventLine(line);
+    if (entry) entries.push(entry);
+  }
+
+  return entries.slice(-maxEntries);
+}
+
+/** Parse a single .jsonl event line into a history entry (or undefined). */
+export function parseEventLine(line: string): HistoryEntry | undefined {
+  const trimmed = line.trim();
+  if (!trimmed) return undefined;
+  let ev: RawEvent;
+  try {
+    ev = JSON.parse(trimmed) as RawEvent;
+  } catch {
+    return undefined;
+  }
+  return toEntry(ev);
+}
+
+/** Build a compact plain-text transcript from history entries (for priming). */
+export function buildTranscript(entries: HistoryEntry[], perEntryMax = 600): string {
+  const label: Record<string, string> = {
+    user: "User",
+    assistant: "Assistant",
+    tool: "Tool",
+    system: "System",
+  };
+  return entries
+    .map((e) => {
+      const text = e.text.length > perEntryMax ? e.text.slice(0, perEntryMax) + " …" : e.text;
+      return `${label[e.role] ?? e.role}: ${text}`;
+    })
+    .join("\n");
+}
+
+function toEntry(ev: RawEvent): HistoryEntry | undefined {
+  const role = roleOf(ev.kind);
+  if (!role) return undefined;
+
+  const text = extractText(ev.data?.content);
+  const tool = ev.data?.tool_name || ev.data?.name;
+  if (!text && !tool) return undefined;
+
+  return {
+    role,
+    text: text || (tool ? `(${tool})` : ""),
+    tool,
+    timestamp: ev.data?.meta?.timestamp,
+  };
+}
+
+function roleOf(kind?: string): HistoryRole | undefined {
+  switch (kind) {
+    case "Prompt":
+    case "UserMessage":
+      return "user";
+    case "AssistantMessage":
+    case "Response":
+      return "assistant";
+    case "ToolUse":
+    case "ToolUseResults":
+      return "tool";
+    default:
+      return undefined;
+  }
+}
+
+function extractText(content?: Array<{ kind?: string; data?: unknown; text?: unknown }>): string {
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const block of content) {
+    if (block.kind === "text") {
+      if (typeof block.data === "string") parts.push(block.data);
+      else if (block.data && typeof (block.data as { text?: unknown }).text === "string") {
+        parts.push((block.data as { text: string }).text);
+      }
+    } else if (typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("").trim();
+}
+
+/** Read up to `maxBytes` from the end of a file as UTF-8 text. */
+function readTail(path: string, maxBytes: number): string {
+  let size: number;
+  try {
+    size = statSync(path).size;
+  } catch {
+    return "";
+  }
+  if (size === 0) return "";
+
+  const start = Math.max(0, size - maxBytes);
+  const length = size - start;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    readSync(fd, buf, 0, length, start);
+    let text = buf.toString("utf-8");
+    // If we started mid-file, drop the partial first line.
+    if (start > 0) {
+      const nl = text.indexOf("\n");
+      if (nl !== -1) text = text.slice(nl + 1);
+    }
+    return text;
+  } finally {
+    closeSync(fd);
+  }
+}

package/src/sessions/store.ts

@@ -0,0 +1,133 @@
+/**
+ * Session store — reads ~/.kiro/sessions/cli to discover existing Kiro CLI
+ * sessions, sorts them by recency, and detects which ones are currently
+ * running on this PC (a .lock file whose PID is alive).
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import type { SessionMeta } from "./types.js";
+
+const log = createLogger("sessions:store");
+
+interface RawSessionJson {
+  session_id?: string;
+  cwd?: string;
+  title?: string;
+  created_at?: string;
+  updated_at?: string;
+  session_created_reason?: string;
+}
+
+interface RawLock {
+  pid?: number;
+  started_at?: string;
+}
+
+export class SessionStore {
+  constructor(private readonly dir: string) {}
+
+  /** Returns true once the sessions directory exists. */
+  available(): boolean {
+    try {
+      return statSync(this.dir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /** List all sessions, most recently updated first. */
+  list(limit = 50): SessionMeta[] {
+    if (!this.available()) return [];
+    let files: string[];
+    try {
+      files = readdirSync(this.dir).filter((f) => f.endsWith(".json"));
+    } catch (e) {
+      log.warn("cannot read sessions dir:", (e as Error).message);
+      return [];
+    }
+
+    const metas: SessionMeta[] = [];
+    for (const file of files) {
+      const meta = this.readMeta(file);
+      if (meta) metas.push(meta);
+    }
+    // Active sessions first, then most-recently-updated.
+    metas.sort(
+      (a, b) => Number(b.active) - Number(a.active) || b.updatedAt.localeCompare(a.updatedAt),
+    );
+    return metas.slice(0, limit);
+  }
+
+  /** List only sessions currently running on this PC. */
+  listActive(): SessionMeta[] {
+    return this.list(200).filter((s) => s.active);
+  }
+
+  get(sessionId: string): SessionMeta | undefined {
+    return this.readMeta(`${sessionId}.json`);
+  }
+
+  jsonlPath(sessionId: string): string {
+    return join(this.dir, `${sessionId}.jsonl`);
+  }
+
+  private readMeta(file: string): SessionMeta | undefined {
+    const full = join(this.dir, file);
+    let raw: RawSessionJson;
+    let mtime = new Date(0).toISOString();
+    try {
+      raw = JSON.parse(readFileSync(full, "utf-8")) as RawSessionJson;
+      mtime = statSync(full).mtime.toISOString();
+    } catch {
+      return undefined;
+    }
+    const sessionId = raw.session_id || file.replace(/\.json$/, "");
+    const base = sessionId;
+
+    const { lockPid, active } = this.checkLock(base);
+    let historyBytes = 0;
+    try {
+      historyBytes = statSync(join(this.dir, `${base}.jsonl`)).size;
+    } catch {
+      /* no history yet */
+    }
+
+    return {
+      sessionId,
+      cwd: raw.cwd || "",
+      title: (raw.title || "").trim() || "(untitled)",
+      createdAt: raw.created_at || mtime,
+      updatedAt: raw.updated_at || mtime,
+      reason: raw.session_created_reason,
+      lockPid,
+      active,
+      historyBytes,
+    };
+  }
+
+  private checkLock(base: string): { lockPid?: number; active: boolean } {
+    try {
+      const lock = JSON.parse(readFileSync(join(this.dir, `${base}.lock`), "utf-8")) as RawLock;
+      if (typeof lock.pid === "number") {
+        return { lockPid: lock.pid, active: isPidAlive(lock.pid) };
+      }
+    } catch {
+      /* no lock => not active */
+    }
+    return { active: false };
+  }
+}
+
+/** Cross-platform "is this process still running?" check. */
+export function isPidAlive(pid: number): boolean {
+  if (!pid || pid <= 0) return false;
+  try {
+    // Signal 0 does not kill; it only checks for existence/permission.
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM means the process exists but we can't signal it => still alive.
+    return (e as NodeJS.ErrnoException).code === "EPERM";
+  }
+}

package/src/sessions/tail.ts

@@ -0,0 +1,86 @@
+/**
+ * TailWatcher — follows a session's .jsonl event log and emits newly appended
+ * entries. Polling (not fs.watch) is used because it is reliable for appends
+ * across platforms and network drives.
+ */
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { createLogger } from "../logger.js";
+import { parseEventLine } from "./history.js";
+import type { HistoryEntry } from "./types.js";
+
+const log = createLogger("sessions:tail");
+
+export class TailWatcher {
+  private pos = 0;
+  private remainder = "";
+  private timer: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly path: string,
+    private readonly onEntries: (entries: HistoryEntry[]) => void,
+    private readonly intervalMs = 1500,
+  ) {}
+
+  /** Start watching. From the current end of file by default (only new events). */
+  start(fromEnd = true): void {
+    if (this.timer) return;
+    try {
+      this.pos = fromEnd ? statSync(this.path).size : 0;
+    } catch {
+      this.pos = 0;
+    }
+    this.timer = setInterval(() => this.poll(), this.intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  get running(): boolean {
+    return this.timer !== undefined;
+  }
+
+  private poll(): void {
+    let size: number;
+    try {
+      size = statSync(this.path).size;
+    } catch {
+      return;
+    }
+    if (size === this.pos) return;
+    if (size < this.pos) {
+      // File rotated/truncated — restart from the beginning.
+      this.pos = 0;
+      this.remainder = "";
+    }
+
+    const length = size - this.pos;
+    let chunk = "";
+    const fd = openSync(this.path, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      readSync(fd, buf, 0, length, this.pos);
+      chunk = buf.toString("utf-8");
+    } catch (e) {
+      log.debug("tail read failed:", (e as Error).message);
+      return;
+    } finally {
+      closeSync(fd);
+    }
+    this.pos = size;
+
+    const text = this.remainder + chunk;
+    const lines = text.split("\n");
+    this.remainder = lines.pop() ?? ""; // keep last partial line
+
+    const entries: HistoryEntry[] = [];
+    for (const line of lines) {
+      const entry = parseEventLine(line);
+      if (entry) entries.push(entry);
+    }
+    if (entries.length > 0) this.onEntries(entries);
+  }
+}

package/src/sessions/types.ts

@@ -0,0 +1,26 @@
+/** Types for discovered Kiro CLI sessions on disk. */
+
+export interface SessionMeta {
+  sessionId: string;
+  cwd: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  reason?: string;
+  /** PID holding the .lock file, if any. */
+  lockPid?: number;
+  /** True when lockPid refers to a live process => running on this PC. */
+  active: boolean;
+  /** Size of the .jsonl history in bytes (proxy for conversation length). */
+  historyBytes: number;
+}
+
+export type HistoryRole = "user" | "assistant" | "tool" | "system";
+
+export interface HistoryEntry {
+  role: HistoryRole;
+  text: string;
+  /** Optional tool name for tool entries. */
+  tool?: string;
+  timestamp?: number;
+}

package/src/stream/streamer.ts

@@ -0,0 +1,167 @@
+/**
+ * ResponseStreamer — renders a whole agent turn into as FEW Telegram messages as
+ * possible, edited at most once per throttle window (anti-spam, avoids 429s).
+ *
+ * The turn is modelled as ordered segments so the transcript reads clearly:
+ *   • plain prose      = the agent talking to you
+ *   • > 💭 quoted block = the agent's thinking
+ *   • 🔧 + code block   = tool calls / terminal commands / diffs
+ *
+ * A single "live" message is edited as content grows; only when it would exceed
+ * Telegram's size limit is it sealed and a new live message started.
+ */
+import type { Api } from "grammy";
+import { chunkMarkdown } from "../render/chunk.js";
+import { toTelegramMarkdown } from "../render/markdown.js";
+import { safeEdit, safeSend } from "../bot/telegram-io.js";
+
+const SOFT_LIMIT = 3500;
+const THINK_TAIL = 500;
+
+type SegKind = "out" | "think" | "tool";
+interface Seg {
+  kind: SegKind;
+  text: string;
+}
+
+export class ResponseStreamer {
+  private readonly segs: Seg[] = [];
+  private sealedIdx = 0;
+  private liveId: number | undefined;
+  private timer: NodeJS.Timeout | undefined;
+  private dirty = false;
+  private flushing = false;
+  private closed = false;
+
+  constructor(
+    private readonly api: Api,
+    private readonly chatId: number,
+    private readonly throttleMs: number,
+  ) {}
+
+  appendOutput(text: string): void {
+    if (!text) return;
+    this.merge("out", text);
+    this.schedule();
+  }
+
+  appendThought(text: string): void {
+    if (!text) return;
+    this.merge("think", text);
+    this.schedule();
+  }
+
+  addTool(rawMarkdown: string): void {
+    if (!rawMarkdown) return;
+    this.segs.push({ kind: "tool", text: rawMarkdown });
+    this.schedule();
+  }
+
+  get hasOutput(): boolean {
+    return this.liveId !== undefined || this.segs.some((s) => s.text.trim().length > 0);
+  }
+
+  async finalize(): Promise<void> {
+    this.closed = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    await this.flush(true);
+  }
+
+  // ── internals ──────────────────────────────────────────────────────────────
+
+  private merge(kind: SegKind, text: string): void {
+    const last = this.segs.at(-1);
+    if (last && last.kind === kind) last.text += text;
+    else this.segs.push({ kind, text });
+  }
+
+  private schedule(): void {
+    if (this.closed) return;
+    this.dirty = true;
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.flush(false);
+    }, this.throttleMs);
+  }
+
+  private async flush(final: boolean): Promise<void> {
+    if (this.flushing) {
+      if (!final) this.schedule();
+      return;
+    }
+    if (!this.dirty && !final) return;
+    this.flushing = true;
+    this.dirty = false;
+    try {
+      await this.sealOverflow();
+      const src = renderSegs(this.segs.slice(this.sealedIdx));
+      if (!src.trim()) return;
+      const rendered = toTelegramMarkdown(src);
+      const chunks = chunkMarkdown(rendered);
+      const plain = chunkMarkdown(src);
+      if (chunks.length <= 1) {
+        const mdv2 = chunks[0] ?? rendered;
+        if (this.liveId === undefined) this.liveId = await safeSend(this.api, this.chatId, mdv2, src);
+        else await safeEdit(this.api, this.chatId, this.liveId, mdv2, src);
+      } else {
+        // Remainder no longer fits one message: flush all, last stays live.
+        for (let i = 0; i < chunks.length; i++) {
+          const mdv2 = chunks[i]!;
+          const p = plain[i] ?? mdv2;
+          if (i === 0 && this.liveId !== undefined) await safeEdit(this.api, this.chatId, this.liveId, mdv2, p);
+          else if (i < chunks.length - 1) await safeSend(this.api, this.chatId, mdv2, p);
+          else this.liveId = await safeSend(this.api, this.chatId, mdv2, p);
+        }
+        this.sealedIdx = this.segs.length; // everything before the live tail is sealed
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+
+  /** Seal leading segments into finalized messages while the live view is too big. */
+  private async sealOverflow(): Promise<void> {
+    let live = this.segs.slice(this.sealedIdx);
+    while (live.length > 1 && toTelegramMarkdown(renderSegs(live)).length > SOFT_LIMIT) {
+      const headCount = live.length - 1;
+      await this.seal(this.sealedIdx, this.sealedIdx + headCount);
+      this.sealedIdx += headCount;
+      this.liveId = undefined;
+      live = this.segs.slice(this.sealedIdx);
+    }
+  }
+
+  private async seal(from: number, to: number): Promise<void> {
+    const src = renderSegs(this.segs.slice(from, to));
+    if (!src.trim()) return;
+    const chunks = chunkMarkdown(toTelegramMarkdown(src));
+    const plain = chunkMarkdown(src);
+    for (let i = 0; i < chunks.length; i++) {
+      const mdv2 = chunks[i]!;
+      const p = plain[i] ?? mdv2;
+      if (i === 0 && this.liveId !== undefined) await safeEdit(this.api, this.chatId, this.liveId, mdv2, p);
+      else await safeSend(this.api, this.chatId, mdv2, p);
+    }
+  }
+}
+
+function renderSegs(segs: Seg[]): string {
+  return segs
+    .map((s) => {
+      if (s.kind === "out") return s.text.trim();
+      if (s.kind === "think") return quoteThought(s.text);
+      return s.text.trim();
+    })
+    .filter((x) => x.length > 0)
+    .join("\n\n");
+}
+
+function quoteThought(text: string): string {
+  const t = text.trim();
+  if (!t) return "";
+  const short = t.length > THINK_TAIL ? "…" + t.slice(-THINK_TAIL) : t;
+  const lines = short.split("\n");
+  return lines.map((l, i) => (i === 0 ? `> 💭 *thinking:* ${l}` : `> ${l}`)).join("\n");
+}