kiro-telegram-bot 1.6.0 → 1.7.1

package/src/render/device-flow.ts

@@ -0,0 +1,76 @@
+/**
+ * Parse the (noisy) stdout of `kiro-cli login --use-device-flow` into the few
+ * stable fields worth showing: the verification URL, the device code, and
+ * whether login completed.
+ *
+ * The CLI animates a spinner ("▰▱▱… Logging in…") by rewriting one terminal
+ * line with carriage returns. With stdio piped the `\r`s are stripped, so those
+ * frames pile up into one long string ("▰▱▱… Logging in…▰▰▱… Logging in…"). We
+ * discard that noise and surface only meaningful values, which the bot renders
+ * on a single, self-animated status line instead of echoing every frame.
+ */
+
+/** Block/braille glyphs the CLI uses to draw progress bars / spinners. */
+const BAR_CHARS = "▰▱▮▯■□▪▫●○◐◓◑◒⣾⣽⣻⢿⡿⣟⣯⣷⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+const BAR_CLASS = `[${BAR_CHARS}]`;
+
+export interface DeviceFlow {
+  /** Verification URL, if the CLI printed one. */
+  url?: string;
+  /** Device/user code (e.g. `VKKH-PPMX`), if present. */
+  code?: string;
+  /** True once the CLI reports a completed login. */
+  loggedIn: boolean;
+  /** A short error line, if the output looks like a failure. */
+  error?: string;
+}
+
+/** Remove spinner frames, repeated "Logging in…" and stray bar glyphs. */
+export function stripSpinner(raw: string): string {
+  return raw
+    .replace(/\r/g, "")
+    .replace(new RegExp(`${BAR_CLASS}+\\s*Logging in[.\\u2026]*`, "gi"), "")
+    .replace(/Logging in[.\u2026]*/gi, "")
+    .replace(new RegExp(`${BAR_CLASS}+`, "g"), "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+const ERROR_RE = /error|failed|denied|expired|invalid|unable|timed out/i;
+
+export function parseDeviceFlow(raw: string): DeviceFlow {
+  const text = stripSpinner(raw);
+
+  // Collect every URL, then prefer the device-verification one (it embeds the
+  // user code, so it's directly clickable). `firstUrl` guards against two URLs
+  // run together with no separator (terminal echo), which would otherwise be
+  // matched as one giant token.
+  const urls = (text.match(/https?:\/\/[^\s'"<>)\]]+/gi) ?? []).map(firstUrl);
+  const url = urls.find((u) => /user_code=|\/device/i.test(u)) ?? urls[0];
+
+  // Prefer the unambiguous XXXX-XXXX shape; fall back to a "Code:" label.
+  const code =
+    text.match(/\b[A-Z0-9]{4}-[A-Z0-9]{4}\b/)?.[0] ??
+    text.match(/Code[:\s]+([A-Z0-9][A-Z0-9-]{3,})/)?.[1];
+
+  const loggedIn = /logged in|login successful|successfully logged in/i.test(text);
+
+  const error =
+    !loggedIn && ERROR_RE.test(text)
+      ? text
+          .split("\n")
+          .map((l) => l.trim())
+          .reverse()
+          .find((l) => ERROR_RE.test(l))
+      : undefined;
+
+  return { url, code, loggedIn, error };
+}
+
+/** Trim a token that accidentally contains two concatenated URLs down to the
+ *  first one (e.g. "https://x/starthttps://x/start" → "https://x/start"). */
+function firstUrl(u: string): string {
+  const second = u.indexOf("http", 4);
+  return second > 0 ? u.slice(0, second) : u;
+}

package/src/render/progress.ts

@@ -0,0 +1,80 @@
+/**
+ * Task-progress support: parse the `{progress: N%}` marker the agent appends to
+ * its messages, strip it from the visible text, and render a green loading bar.
+ *
+ * The agent is asked (see PROGRESS_DIRECTIVE) to end each message with a marker
+ * like `{progress: 65%}`. The bot extracts the latest value, removes the marker
+ * so it never shows raw, and renders a 0–100% bar (filled = 🟩, empty = ⬜) on
+ * the live message, in session cards, and in the pinned status panel.
+ */
+
+/** Matches a complete marker: `{progress: 65%}`, `{ progress:65 }`, etc. */
+const PROGRESS_RE = /\{\s*progress\s*:\s*(\d{1,3})\s*%?\s*\}/gi;
+/** Matches a trailing, not-yet-closed marker mid-stream (e.g. `…{progress: 6`). */
+const PARTIAL_TAIL_RE = /\{\s*progress\b[^}]*$/i;
+
+const FILLED = "\u{1F7E9}"; // 🟩
+const EMPTY = "\u2B1C"; // ⬜
+const SEGMENTS = 10;
+
+/**
+ * The instruction appended to prompts so the agent emits a progress marker.
+ *
+ * IMPORTANT for maintainers:
+ *  - The ONLY brace token may be the literal `{progress: N%}` with the letter
+ *    `N` (never a digit). A digit inside braces would be parsed by PROGRESS_RE
+ *    as a real value AND would break the exact-string strip in
+ *    `sessions/history.ts` (`cleanStoredText`).
+ *  - Keep this string "tidy-idempotent": no trailing spaces on any line, no run
+ *    of 3+ newlines, and no trailing whitespace at the end. `cleanStoredText`
+ *    runs `extractProgress` (which calls `tidy()`) before stripping the
+ *    directive by exact match, so any whitespace `tidy()` would rewrite must
+ *    not appear here, or the directive leaks into history/previews.
+ */
+export const PROGRESS_DIRECTIVE = [
+  "PROGRESS REPORTING IS MANDATORY ON EVERY SINGLE MESSAGE YOU SEND \u2014 NO EXCEPTIONS.",
+  "Rule 1 (format): finish EVERY message with a task-completion marker on its own final line, in EXACTLY this format, with nothing at all after it: {progress: N%}",
+  "N is a plain integer from 0 to 100 (no decimals, no ranges, no math). The marker is the very last thing in the message: no text, punctuation, spaces, emoji, backticks, or code fences may follow it, and it must NEVER be placed inside a code block or quote.",
+  "Rule 2 (frequency): emit the marker on your FIRST message, on EVERY intermediate message, after EVERY tool call or group of tool calls, around any subagent delegation, and on your FINAL message. Short replies, plans, questions, acknowledgements, clarifications, errors, and tool-only or status updates are NOT exempt \u2014 if you output any text at all, it ends with the marker. Do not batch it only into the last message.",
+  "Rule 3 (compute it for real, never random): before each message, decompose the overall task into the concrete steps it actually needs (understand the request, read the relevant files, each separate edit, run the build/tests, fix failures, verify) and set N = round(100 * completed_steps / total_steps), re-estimated fresh from the real current state each time.",
+  "Rule 4 (be granular and honest): start low (about 5 to 15 on your first message; use 0 only when literally nothing is started yet), then climb in realistic increments that mirror real progress. Do NOT jump from a low number straight to a high one, and do NOT keep repeating the same number across messages while work is clearly advancing.",
+  "Rule 5 (monotonic): within one task the number must NEVER decrease \u2014 each marker is greater than or equal to the previous one you emitted.",
+  "Rule 6 (terminal): report 100 ONLY when the entire task is fully complete and verified with nothing left to do. While ANY work, fix, verification, question, or follow-up remains, cap the number at 99.",
+  "The client parses this marker, removes it from the visible text, and renders it as a live progress bar, so its presence on every message and the accuracy of the number both matter.",
+].join("\n");
+
+export interface ProgressExtract {
+  /** Latest progress value found (0–100), or undefined if none. */
+  value?: number;
+  /** The input text with all progress markers removed. */
+  cleaned: string;
+}
+
+/** Pull the latest `{progress: N%}` value out of `text` and strip every marker
+ *  (plus any trailing half-streamed marker so it never flashes raw). */
+export function extractProgress(text: string): ProgressExtract {
+  let value: number | undefined;
+  let cleaned = text.replace(PROGRESS_RE, (_m, digits: string) => {
+    const v = Math.max(0, Math.min(100, Number.parseInt(digits, 10)));
+    if (Number.isFinite(v)) value = v; // keep the LAST occurrence (most recent)
+    return "";
+  });
+  cleaned = cleaned.replace(PARTIAL_TAIL_RE, "");
+  return { value, cleaned: tidy(cleaned) };
+}
+
+/** Tidy whitespace left behind by a removed marker. */
+function tidy(s: string): string {
+  return s
+    .replace(/[ \t]+\n/g, "\n") // trailing spaces on lines
+    .replace(/\n{3,}/g, "\n\n") // collapse blank-line runs
+    .replace(/\s+$/g, ""); // trailing whitespace/newlines
+}
+
+/** A 10-segment green progress bar, e.g. `🟩🟩🟩🟩🟩⬜⬜⬜⬜⬜ 50%` (✅ at 100%). */
+export function progressBar(pct: number): string {
+  const v = Math.max(0, Math.min(100, Math.round(pct)));
+  const filled = Math.round((v / 100) * SEGMENTS);
+  const bar = FILLED.repeat(filled) + EMPTY.repeat(SEGMENTS - filled);
+  return `${bar} ${v}%${v >= 100 ? " \u2705" : ""}`;
+}

package/src/service/windows.ts

@@ -1,23 +1,68 @@
 /**
- * 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.
+ * Windows service controller — runs the bot at logon. Preferred mechanism is a
+ * hidden ONLOGON Scheduled Task, but registering a logon-triggered task needs
+ * admin, so from a normal (non-elevated) terminal we fall back to a launcher in
+ * the per-user Startup folder — both run a small .vbs that starts node with no
+ * console window; the app logs to a file. Stop precisely targets our node
+ * process by command line, so it works regardless of how it was launched.
  */
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, 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";
+/** Launcher dropped in the per-user Startup folder when no admin is available. */
+const STARTUP_VBS = "KiroTelegramBot.vbs";
+
+/** The per-user Startup folder (runs at logon for the current user, no admin).
+ *  Undefined only if APPDATA is unset (e.g. running with no roaming profile). */
+function startupDir(): string | undefined {
+  const appData = process.env.APPDATA;
+  return appData ? join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup") : undefined;
+}
+
+function startupVbsPath(): string | undefined {
+  const dir = startupDir();
+  return dir ? join(dir, STARTUP_VBS) : undefined;
+}
+
+/** Remove a leftover Startup-folder launcher (e.g. from an earlier non-elevated
+ *  install) so a task-based install never double-launches the bot at logon. */
+function removeStartupLauncher(): void {
+  const p = startupVbsPath();
+  if (p) rmSync(p, { force: true });
+}
+
+/** Canonical launcher in the bot folder (the Scheduled Task points at it). */
+function vbsPath(spec: LaunchSpec): string {
+  return join(spec.cwd, "run-service.vbs");
+}
+
+/** True when our hidden Scheduled Task is registered. */
+function taskInstalled(): boolean {
+  return runSafe("schtasks", ["/Query", "/TN", TASK]).ok;
+}
+
+/** True when a bot process matching this spec is currently running. Launch
+ *  paths use this to avoid starting a second instance — two pollers on one
+ *  bot token make Telegram return 409 Conflict. */
+function isRunning(spec: LaunchSpec): boolean {
+  const proc = runSafe("powershell", ["-NoProfile", "-Command", countScript(entryOf(spec))]);
+  return proc.ok && /[1-9]\d*/.test(proc.out.trim());
+}
 
 export const windowsController: ServiceController = {
   platform: "windows",
 
   async install(spec) {
     mkdirSync(spec.logsDir, { recursive: true });
-    const vbs = join(spec.cwd, "run-service.vbs");
+    const vbs = vbsPath(spec);
     writeFileSync(vbs, vbsLauncher(spec), "utf-8");
 
+    // Preferred: a hidden ONLOGON Scheduled Task. Registering a *logon-triggered*
+    // task is a privileged operation, so /Create succeeds only from an elevated
+    // (admin) terminal. From a normal terminal it returns "Access is denied".
     runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]); // replace if present
     const res = runSafe("schtasks", [
       "/Create",
@@ -29,37 +74,87 @@ export const windowsController: ServiceController = {
       "/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.`);
+    if (res.ok) {
+      removeStartupLauncher(); // avoid a leftover launcher double-starting the bot
+      if (!isRunning(spec)) runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return ok(`Installed scheduled task "${TASK}" (starts at logon) and launched it.`);
+    }
+
+    // A task may still exist that we just couldn't overwrite (e.g. created by an
+    // earlier elevated install). Reuse it rather than ALSO adding a Startup
+    // launcher, which would double-launch the bot at logon (409 Conflict).
+    if (taskInstalled()) {
+      removeStartupLauncher();
+      if (!isRunning(spec)) runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return ok(`Scheduled task "${TASK}" already exists; launched it. (Re-run elevated to recreate it.)`);
+    }
+
+    // Fallback (no admin — the common case): drop the launcher in the per-user
+    // Startup folder. It runs hidden at every logon with no elevation.
+    const startupVbs = startupVbsPath();
+    const dir = startupDir();
+    if (!startupVbs || !dir) {
+      return fail(
+        `Could not create the logon task (${res.out.trim()}) and no per-user Startup folder is available. ` +
+          `Re-run "kiro-tg install" from an elevated terminal (Run as administrator).`,
+      );
+    }
+    try {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(startupVbs, vbsLauncher(spec), "utf-8");
+    } catch (e) {
+      return fail(`Startup-folder install failed: ${(e as Error).message}`);
+    }
+    if (!isRunning(spec)) runSafe("wscript.exe", [startupVbs]); // launch now
+    return ok(
+      `Installed via the Startup folder — starts hidden at logon, no admin needed — and launched it.\n` +
+        `(Tip: run "kiro-tg install" from an elevated terminal to use a hidden Scheduled Task instead.)`,
+    );
   },
 
   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);
+    runSafe("schtasks", ["/Delete", "/F", "/TN", TASK]); // best-effort (may not exist)
+    rmSync(vbsPath(spec), { force: true });
+    const startupVbs = startupVbsPath();
+    if (startupVbs) rmSync(startupVbs, { force: true });
+    return ok(`Removed "${TASK}" (scheduled task and/or Startup launcher).`);
   },
 
-  async start() {
-    const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
-    return res.ok ? ok("Started.") : fail(res.out);
+  async start(spec) {
+    if (isRunning(spec)) return ok("Already running.");
+    if (taskInstalled()) {
+      const res = runSafe("schtasks", ["/Run", "/TN", TASK]);
+      return res.ok ? ok("Started.") : fail(res.out);
+    }
+    const startupVbs = startupVbsPath();
+    if (startupVbs && existsSync(startupVbs)) {
+      runSafe("wscript.exe", [startupVbs]);
+      return ok("Started.");
+    }
+    return fail(`Not installed. Run "kiro-tg install" first.`);
   },
 
   async stop(spec) {
-    runSafe("schtasks", ["/End", "/TN", TASK]);
+    runSafe("schtasks", ["/End", "/TN", TASK]); // best-effort if task-based
     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;
+    const installedTask = taskInstalled();
+    const startupVbs = startupVbsPath();
+    const installedStartup = !!startupVbs && existsSync(startupVbs);
+    const installed = installedTask || installedStartup;
+    const running = isRunning(spec);
+    const how = installedTask ? "scheduled task" : installedStartup ? "Startup folder" : "—";
+    const detail = installedTask
+      ? `\n${runSafe("schtasks", ["/Query", "/TN", TASK, "/FO", "LIST"]).out.trim()}`
+      : installedStartup
+        ? `\nLauncher: ${startupVbs}`
+        : "";
     return ok(
-      `Installed: ${installed ? "yes" : "no"} | Running: ${running ? "yes" : "no"}\n` +
-        (installed ? task.out.trim() : "Task not found."),
+      `Installed: ${installed ? `yes (${how})` : "no"} | Running: ${running ? "yes" : "no"}${detail}`,
     );
   },
 };

package/src/sessions/history.ts

@@ -3,6 +3,7 @@
  * Reads only the tail of large logs to stay fast.
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { extractProgress, PROGRESS_DIRECTIVE } from "../render/progress.js";
 import type { HistoryEntry, HistoryRole } from "./types.js";
 
 const TAIL_WINDOWS = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024]; // grow until entries found
@@ -141,7 +142,7 @@ function toEntry(ev: RawEvent): HistoryEntry | undefined {
   const role = roleOf(ev.kind);
   if (!role) return undefined;
 
-  const text = extractText(ev.data?.content);
+  const text = cleanStoredText(extractText(ev.data?.content));
   const tool = ev.data?.tool_name || ev.data?.name;
   if (!text && !tool) return undefined;
 
@@ -153,6 +154,16 @@ function toEntry(ev: RawEvent): HistoryEntry | undefined {
   };
 }
 
+/** Strip the `{progress: N%}` markers (any role) and the appended progress
+ *  directive (user prompts) from persisted text so history / unread / previews
+ *  / fork-priming never surface the raw plumbing. */
+function cleanStoredText(text: string): string {
+  if (!text) return text;
+  let t = extractProgress(text).cleaned;
+  if (t.includes(PROGRESS_DIRECTIVE)) t = t.split(PROGRESS_DIRECTIVE).join("").trim();
+  return t;
+}
+
 function roleOf(kind?: string): HistoryRole | undefined {
   switch (kind) {
     case "Prompt":

package/src/sessions/process.ts

@@ -0,0 +1,30 @@
+/**
+ * Process control helpers for Kiro sessions: force-killing the process that
+ * holds a session's `.lock` (its `lockPid`). Shared by /killall and the
+ * per-session kill button so the behaviour stays identical.
+ */
+import { execFileSync } from "node:child_process";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("sessions:process");
+
+/**
+ * Force-kill a process by PID — and its child tree on Windows (`taskkill /T`),
+ * which a `kiro-cli` session may have spawned (shells, tools). Returns whether
+ * the kill command was issued without throwing. A non-existent PID or one we
+ * may not signal counts as failure (callers report it).
+ */
+export function killPid(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  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;
+  }
+}

package/src/stream/streamer.ts

@@ -13,6 +13,7 @@
 import type { Api } from "grammy";
 import { chunkMarkdown } from "../render/chunk.js";
 import { toTelegramMarkdown } from "../render/markdown.js";
+import { extractProgress, progressBar } from "../render/progress.js";
 import { safeEdit, safeSend } from "../bot/telegram-io.js";
 
 const SOFT_LIMIT = 3500;
@@ -32,6 +33,9 @@ export class ResponseStreamer {
   private dirty = false;
   private flushing = false;
   private closed = false;
+  /** Latest task-progress % parsed from the agent's `{progress: N%}` markers
+   *  (sticky across flushes; rendered as a bar on the live message). */
+  private progress: number | undefined;
 
   constructor(
     private readonly api: Api,
@@ -39,6 +43,7 @@ export class ResponseStreamer {
     private readonly throttleMs: number,
     private replyTo?: number,
     private footer?: string,
+    private readonly onProgress?: (pct: number) => void,
   ) {}
 
   /** Replace the hashtag footer (used after a logical fork swaps the session id
@@ -52,6 +57,21 @@ export class ResponseStreamer {
     return this.footer ? `\n\n${this.footer}` : "";
   }
 
+  /** Strip `{progress: N%}` markers from rendered text, remembering the latest
+   *  value (sticky across flushes) and notifying the owner when it changes. */
+  private captureProgress(text: string): string {
+    const { value, cleaned } = extractProgress(text);
+    if (value !== undefined && value !== this.progress) {
+      this.progress = value;
+      try {
+        this.onProgress?.(value);
+      } catch {
+        /* non-fatal */
+      }
+    }
+    return cleaned;
+  }
+
   /** reply_parameters threading EVERY message of the turn to the user's prompt,
    *  so the whole response (all bubbles, tool calls and continuations) stays in
    *  one thread — not just the first message. */
@@ -117,11 +137,14 @@ export class ResponseStreamer {
     this.dirty = false;
     try {
       await this.sealOverflow();
-      const base = renderSegs(this.segs.slice(this.sealedIdx));
-      if (!base.trim()) return;
-      // Every bubble — including the still-streaming live one — carries the
-      // hashtag footer so the thinking/first response is tagged immediately.
-      const src = `${base}${this.footerSuffix()}`;
+      const base = this.captureProgress(renderSegs(this.segs.slice(this.sealedIdx)));
+      if (!base.trim() && this.progress === undefined) return;
+      // The live (still-streaming) bubble carries the hashtag footer AND a fresh
+      // progress bar at the bottom (sealed bubbles below get neither bar).
+      const parts: string[] = [];
+      if (base.trim()) parts.push(base);
+      if (this.progress !== undefined) parts.push(progressBar(this.progress));
+      const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
       const rendered = toTelegramMarkdown(src);
       const chunks = chunkMarkdown(rendered);
       const plain = chunkMarkdown(src);
@@ -158,7 +181,7 @@ export class ResponseStreamer {
   }
 
   private async seal(from: number, to: number): Promise<void> {
-    const base = renderSegs(this.segs.slice(from, to));
+    const base = this.captureProgress(renderSegs(this.segs.slice(from, to)));
     if (!base.trim()) return;
     // A sealed bubble is finished, so it carries the footer (hashtags).
     const src = `${base}${this.footerSuffix()}`;