kiro-telegram-bot 1.6.0 → 1.7.1

package/CHANGELOG.md

@@ -7,6 +7,103 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 The latest section is published verbatim as the GitHub Release notes by
 `.github/workflows/release.yml` when a `vX.Y.Z` tag is pushed.
 
+## [1.7.1] - 2026-06-24
+
+The **"sign in your way"** release — `/reauth` now lets you pick how you log in
+(Builder ID, Google, GitHub or IAM Identity Center) on one tidy status card, and
+the live task-progress bar climbs steadily instead of appearing only at the end.
+
+### Added
+
+- **🔐 `/reauth` login-method picker.** Re-authentication now opens with a
+  **picker** — **Builder ID** (free), **Google**, **GitHub**, or **IAM Identity
+  Center** (Pro) — driven on a **single, self-animated status message** with
+  inline **Cancel · Retry · Change method · Restart agent** controls, so the chat
+  no longer fills with raw spinner frames. **IAM Identity Center** sign-in is now
+  fully supported: the bot asks for your **start URL + region** and drives the
+  CLI's interactive prompts inside a pseudo-terminal (optional
+  `@homebridge/node-pty-prebuilt-multiarch` dependency; a clear message tells you
+  to run `npm install` if it's missing). The device-verification URL + code still
+  stream to the chat for every method. Power users can skip the picker by passing
+  flags directly, e.g. `/reauth --license pro --identity-provider <url> --region <region>`.
+
+### Changed
+
+- **📈 Stricter, steadier task-progress reporting.** The agent instruction behind
+  the `{progress: N%}` marker is now far more rigorous: a marker is required on
+  **every** message (not only the last), the number must be **computed from real
+  step completion** and is **monotonic** (never decreases within a task), and
+  **100 %** is reserved for work that is fully complete *and verified*. The bar
+  now advances in realistic increments instead of jumping to a value at the very
+  end.
+
+### Fixed
+
+- **🔁 `/reauth` agent-restart race** (`agent restart failed: kiro-cli acp exited
+  (code null)`). Logging out and restarting could let the **old** agent process's
+  exit fail the **new** connection's `initialize` and even trigger a competing
+  auto-restart. The ACP client now **fully tears down** the previous process
+  (ignoring the exit of a process it has already replaced) **before** spawning a
+  fresh one, and `/reauth` takes the agent down and **waits** before logging out —
+  so a deliberate restart is clean and the new identity sticks.
+- **🪪 Stale identity after re-login.** On logout the bot now also **clears Kiro's
+  cached auth token** (`~/.aws/sso/cache/kiro-auth-token.json`), so the next login
+  performs a genuine device-flow authentication instead of silently reusing the
+  previous account's refreshable token.
+
+## [1.7.0] - 2026-06-23
+
+The **"take control"** release — stop a runaway session by PID, re-authenticate
+Kiro from your phone, watch a live task-progress bar, and install on Windows
+without admin.
+
+### Added
+
+- **🛑 Kill a session / PID from its card (`/sessions`, `/active`).** Every
+  **live** session card now has a **`🛑 Kill · pid N`** button that terminates
+  that session's process — and its whole child tree on Windows (`taskkill /T`).
+  It's guarded by an inline **confirm** (Kill / Cancel) since it's destructive,
+  the bot's **own** agent process is never offered (killing it would take the
+  bot down), and the session state is re-read at every step so a session that
+  already stopped reports "no longer running" instead of a phantom kill. The
+  existing `/killall` (stop every active session at once) is unchanged and now
+  shares the same kill logic.
+- **🔐 Re-authenticate Kiro from Telegram (`/reauth`).** Logs out
+  (`kiro-cli logout`) and starts a fresh **device-flow** login
+  (`kiro-cli login --use-device-flow`) — the verification URL + code are
+  **streamed into the chat** so you complete it on your own device — then
+  **restarts the agent** so it picks up the new credentials. Refused while a
+  turn is in flight (logging out would break it) and serialised so two runs
+  can't overlap. Pass-through flags are supported, e.g.
+  `/reauth --license free` or `/reauth --license pro --region <r> --identity-provider <url>`.
+- **📈 Live task-progress bar (`SHOW_PROGRESS`, on by default).** The agent is
+  asked to end each message with a `{progress: N%}` marker; the bot **parses and
+  hides** it and renders a **green 0–100 % loading bar** (`🟩🟩🟩⬜⬜⬜ 50%`,
+  all-green ✅ at 100 %) at the bottom of the **live message**, in the pinned
+  **status panel**, and on **`/running` and `/sessions` cards** — so you can see
+  how far along the current task is. Markers (and the instruction) are also
+  stripped from history, unread replays, previews and fork-priming, so the raw
+  plumbing never shows. Disable with `SHOW_PROGRESS=false`.
+- **🔀 "Switch to this session" on background pings.** A **`📨 From other
+  session`** Done/error notification now carries a **🔀 Switch to this session**
+  button that brings that session to the foreground in one tap.
+
+### Changed
+
+- **🪟 Windows install no longer needs admin.** `kiro-tg install` used to fail
+  with **`schtasks create failed: ERROR: Access is denied`** for a normal user,
+  because registering a **logon-triggered** Scheduled Task is a privileged
+  operation. The installer now falls back to a hidden per-user **Startup-folder**
+  launcher (runs at logon, **no elevation**) when the task can't be created; an
+  **elevated** run still uses the nicer hidden Scheduled Task. `install`,
+  `start`, `stop`, `status` and `uninstall` understand both mechanisms, and a
+  pre-launch running-check prevents a **double-launch** (two pollers on one bot
+  token would otherwise trigger Telegram 409 Conflict).
+- **🔕 No interim "Done" ping from a busy background session.** A background
+  ("other session") turn that still has **queued follow-ups** no longer pings an
+  intermediate "Done" — only the final, queue-empty turn announces completion,
+  so a session working through a queue doesn't spam you between steps.
+
 ## [1.6.0] - 2026-06-23
 
 The **"always-on & self-healing"** release — the bot keeps itself up to date,
@@ -300,6 +397,8 @@ from a single chat and switch between them, on a redesigned, compact menu.
   diffs, MarkdownV2 rendering, scheduled tasks, multi-image prompts, and a
   cross-platform 24/7 background service.
 
+[1.7.1]: https://github.com/artickc/kiro-telegram-bot/releases/tag/v1.7.1
+[1.7.0]: https://github.com/artickc/kiro-telegram-bot/releases/tag/v1.7.0
 [1.6.0]: https://github.com/artickc/kiro-telegram-bot/releases/tag/v1.6.0
 [1.5.1]: https://github.com/artickc/kiro-telegram-bot/releases/tag/v1.5.1
 [1.5.0]: https://github.com/artickc/kiro-telegram-bot/releases/tag/v1.5.0

package/README.md

@@ -27,6 +27,7 @@ and extended into a full multi-session client.
 | 🗂 **Projects** | `/projects` browses your folders and runs Kiro in the one you pick. |
 | ♻️ **Resume sessions** | `/sessions` lists recent Kiro sessions; tap to resume via ACP `session/load`. |
 | 🟢 **Connect to live sessions** | `/active` shows sessions running **right now** on your PC. Watch them live, or continue them — see below. |
+| 🛑 **Kill a session / PID** | Each live `/sessions` · `/active` card has a **🛑 Kill · pid N** button (confirm-guarded) that stops that session's process and its child tree; `/killall` stops them all. The bot's own agent is never killable. |
 | 📡 **Live watch** | Follow a running session read-only in real time (tails its event log). |
 | 🧭 **Always-visible menu** | A persistent keyboard plus a pinned status panel that always shows your current **project, agent, reasoning effort, model, session and queue**. |
 | ⏰ **Scheduled tasks** | Create prompts that run on a schedule (once / daily / weekly / monthly / every-N-minutes) in a chosen project, delivered back to your chat. |
@@ -34,6 +35,8 @@ and extended into a full multi-session client.
 | 📜 **History** | `/history` shows the latest messages of any session. |
 | 🧩 **MCP control** | `/mcp` lists MCP servers, **health-checks** them (which connected / failed and why), and **enables/disables** them — then restarts the agent to apply. |
 | 👥 **Subagent visibility** | When Kiro delegates to subagents and waits on them, you see each one **start / work / finish** plus a live `🤖 N running` summary — and subagent permission prompts route to your chat. |
+| 📈 **Task progress bar** | The agent appends a `{progress: N%}` marker; the bot hides it and shows a **green 0–100% loading bar** on the live message, in the status panel, and on session cards (`SHOW_PROGRESS`). |
+| 🔐 **Re-auth from chat** | `/reauth` logs out and runs a device-flow login (URL + code streamed to your chat), then restarts the agent — no terminal needed. |
 | ⌨️ **Typing indicator** | Stays on for the whole turn, even through long tool chains. |
 | 📥 **Queued follow-ups** | Message while Kiro is busy — it's queued and runs next. `/btw` runs it ASAP (now if idle, else right after the current task); `/flush` runs the queue now. |
 | ✏️ **Edit diffs** | File edits show as unified `diff` blocks with `+N -M` stats. |
@@ -52,6 +55,9 @@ and extended into a full multi-session client.
 | Switch between projects | ✅ | ❌ |
 | Resume saved sessions | ✅ | ❌ |
 | Attach to **live** PC sessions (watch / fork) | ✅ | ❌ |
+| **Kill a session by PID** (or all at once) | ✅ | ❌ |
+| **Live task-progress bars** (`{progress: N%}`) | ✅ | ❌ |
+| **Re-authenticate from chat** (`/reauth`, device flow) | ✅ | ❌ |
 | Multiple isolated sessions | ✅ | ❌ (single shared) |
 | Queued follow-ups while busy | ✅ | ❌ |
 | **Scheduled tasks** (cron-like) | ✅ | ❌ |
@@ -139,10 +145,16 @@ The platform is auto-detected:
 
 | OS | Mechanism | Starts on |
 |---|---|---|
-| Windows | Hidden Scheduled Task | logon |
+| Windows | Hidden Scheduled Task (elevated) · per-user **Startup folder** (no admin) | logon |
 | Linux | systemd **user** service (+ linger) | boot |
 | macOS | launchd LaunchAgent | login |
 
+On Windows, registering a logon-triggered Scheduled Task needs admin, so from a
+normal terminal `kiro-tg install` falls back to a hidden launcher in your
+per-user **Startup folder** (starts at logon, no elevation). Run it from an
+**elevated** terminal to use the Scheduled Task instead; either way `status`,
+`stop`, `restart` and `uninstall` work the same.
+
 ```bash
 npm run install:service     # install + start, enable autostart
 npm run service -- status   # show install + running state
@@ -182,6 +194,7 @@ Logs are written to `logs/kiro-telegram-bot.log` (rotated at 5 MB).
 /unwatch      Stop following a live session
 /model <id>   Switch the model for this session
 /restart      Restart the Kiro agent
+/reauth       Log out & log in to Kiro (device flow) · /reauth --license free|pro …
 /help         Show help
 ```
 
@@ -199,10 +212,10 @@ Sessions · Agent · Model · Reasoning · Tasks · Status · Usage · Stop · K
 The bar can be hidden (🙈) and restored (⌨️ Show bar or `/menu`).
 
 A **pinned status panel** at the top of the chat always shows your current
-**project, agent, reasoning effort, model, session id, context %, activity and
-queue** (and how many sessions the chat controls), updating live. Pick **Agent**,
-**Reasoning** or **Model** from the inline menu (reasoning steers how thoroughly
-the agent works: Minimal → Max).
+**project, agent, reasoning effort, model, session id, context %, task progress,
+activity and queue** (and how many sessions the chat controls), updating live.
+Pick **Agent**, **Reasoning** or **Model** from the inline menu (reasoning steers
+how thoroughly the agent works: Minimal → Max).
 
 ## ⏰ Scheduled tasks
 
@@ -237,6 +250,25 @@ prompt. Configure any OpenAI/Whisper-compatible endpoint via `STT_API_URL` in
 `.env`; leave `STT_LANGUAGE` blank for automatic detection (English, Russian,
 Romanian/Moldovan, and ~100 more).
 
+## 📈 Task progress
+
+The bot asks the agent to end each message with a `{progress: N%}` marker, then
+**hides the marker** and renders a **green loading bar** from 0–100 %
+(`🟩🟩🟩🟩🟩⬜⬜⬜⬜⬜ 50%`, all-green ✅ at 100 %) so you can see how far along the
+current task is. The bar appears at the bottom of the **live message**, in the
+pinned **status panel**, and on **`/running` and `/sessions` cards**. Markers are
+also stripped from history, replays and previews, so the raw plumbing never
+shows. Turn it off with `SHOW_PROGRESS=false`.
+
+## 🔐 Re-authenticating Kiro
+
+Run **`/reauth`** to log out and start a fresh **device-flow** login without
+touching a terminal: the verification URL + code are streamed into the chat
+(open them on any device), and once you're logged in the agent is restarted to
+pick up the new credentials. It's refused while a turn is running, and you can
+pass login flags through, e.g. `/reauth --license free` or
+`/reauth --license pro --region <r> --identity-provider <url>`.
+
 ---
 
 ## 🧭 Working on several sessions at once
@@ -248,7 +280,8 @@ while the others keep working quietly. When you switch to a session you see its
 recent context and **every message that arrived while you were away** (its
 unread, recovered from the session log). Leave a task running in A, hop to B,
 reply, and come back to A to read what it did. Close a session with ✖ (it isn't
-killed — see `/killall` for that).
+killed) — or tap **🛑 Kill · pid N** on its `/sessions` · `/active` card to stop
+its process (and `/killall` to stop them all).
 
 ## 🔗 Connecting to live sessions
 
@@ -283,6 +316,7 @@ Resuming an **idle** session loads it directly so you continue the exact thread.
 | `SHOW_EDIT_DIFFS` | no | `true` | Show unified diffs for edits. |
 | `DIFF_MAX_LINES` | no | `120` | Max diff lines shown inline. |
 | `SHOW_SUBAGENTS` | no | `true` | Stream subagent (crew) start/work/finish while the main agent waits. |
+| `SHOW_PROGRESS` | no | `true` | Ask the agent to append a `{progress: N%}` marker to each message; the bot parses it, hides the marker, and renders a green 0–100% bar on the live message, in session cards, and in the status panel. |
 | `NOTIFY_OTHER_SESSIONS` | no | `true` | Deliver a session's "Done" summary (with a short created/edited/deleted count) even when it's a background session, marked "From other session". `false` keeps background sessions silent. |
 | `MCP_PROBE_TIMEOUT_MS` | no | `8000` | Per-server timeout for the `/mcp` live health-check. |
 | `MCP_PROBE_CONCURRENCY` | no | `6` | How many MCP health probes run at once. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-telegram-bot",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Control Kiro CLI from Telegram over the Agent Client Protocol (ACP). Switch projects, resume and attach to live coding sessions, stream responses with diffs, queue follow-ups, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",
@@ -63,6 +63,9 @@
     "grammy": "^1.30.0",
     "tsx": "^4.19.2"
   },
+  "optionalDependencies": {
+    "@homebridge/node-pty-prebuilt-multiarch": "0.13.1"
+  },
   "devDependencies": {
     "@types/diff": "^7.0.0",
     "@types/node": "^22.10.0",

package/src/acp/client.ts

@@ -159,24 +159,31 @@ export class AcpClient extends EventEmitter {
     if (this.opts.agent) args.push("--agent", this.opts.agent);
 
     log.info(`spawning: ${this.opts.kiroCliPath} ${args.join(" ")}`);
-    this.proc = spawn(this.opts.kiroCliPath, args, {
+    const proc = spawn(this.opts.kiroCliPath, args, {
       stdio: ["pipe", "pipe", "pipe"],
       cwd: this.opts.workspace,
       env: { ...process.env, KIRO_LOG_LEVEL: process.env.KIRO_LOG_LEVEL || "error" },
     }) as ChildProcessWithoutNullStreams;
-
-    this.proc.on("exit", (code) => {
+    this.proc = proc;
+
+    proc.on("exit", (code) => {
+      // Ignore the exit of a process we've already replaced (a deliberate
+      // restart/stop). Its teardown must NOT fail the new process's pending
+      // requests nor trigger a competing auto-restart — that race was the cause
+      // of "/reauth → agent restart failed: kiro-cli acp exited (code null)".
+      if (this.proc !== proc) return;
       log.warn(`kiro-cli acp exited (code ${code})`);
       this.failAllPending(new Error(`kiro-cli acp exited (code ${code})`));
       this.emit("exit", code);
       this.maybeRestart();
     });
-    this.proc.on("error", (err) => {
+    proc.on("error", (err) => {
+      if (this.proc !== proc) return;
       log.error("failed to spawn kiro-cli:", err.message);
       this.failAllPending(err);
     });
 
-    this.transport = new JsonRpcTransport(this.proc);
+    this.transport = new JsonRpcTransport(proc);
     this.transport.on("message", (m: JsonRpcMessage) => this.onMessage(m));
 
     const init = (await this.request("initialize", {
@@ -329,22 +336,87 @@ export class AcpClient extends EventEmitter {
 
   stop(): void {
     this.stopped = true;
-    if (this.restartTimer) clearTimeout(this.restartTimer);
-    this.proc?.kill();
-    this.proc = undefined;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = undefined;
+    }
+    void this.killCurrent();
   }
 
-  /** Manually restart the agent (used by the /restart command). */
-  async restart(): Promise<void> {
+  /**
+   * Stop the agent and WAIT for the process to fully exit, leaving it stopped
+   * (no auto-restart until start()/restart()). Used by /reauth to release the
+   * held session BEFORE logging out — otherwise the live agent keeps refreshing
+   * and re-persisting the old token, silently restoring the previous identity.
+   */
+  async stopAndWait(): Promise<void> {
     this.stopped = true;
-    if (this.restartTimer) clearTimeout(this.restartTimer);
-    this.proc?.kill();
-    this.proc = undefined;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = undefined;
+    }
+    await this.killCurrent();
+  }
+
+  /**
+   * Manually restart the agent (used by /restart, /reauth and the MCP toggle).
+   * The old process is fully torn down BEFORE a fresh one is spawned, so its
+   * exit can't fail the new connection's `initialize` — which previously
+   * surfaced as "agent restart failed: kiro-cli acp exited (code null)".
+   */
+  async restart(): Promise<void> {
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = undefined;
+    }
+    this.stopped = true; // suppress auto-restart while we swap processes
+    this.restartAttempts = 0;
+    await this.killCurrent();
     this.stopped = false;
     await this.connect();
     this.emit("restarted");
   }
 
+  /**
+   * Terminate the current process and wait for it to fully exit. Clearing
+   * `this.proc` first makes the connect()-registered exit/error handlers
+   * short-circuit, so a deliberate teardown is silent (no `exit` event, no
+   * auto-restart). In-flight requests are rejected here (the handler no longer
+   * will). Escalates to SIGKILL if the process lingers, and never hangs.
+   */
+  private killCurrent(): Promise<void> {
+    const proc = this.proc;
+    this.proc = undefined;
+    this.transport = undefined;
+    this.failAllPending(new Error("kiro-cli acp is restarting"));
+    if (!proc || proc.exitCode !== null || proc.signalCode !== null) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      let settled = false;
+      const done = (): void => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(hard);
+        resolve();
+      };
+      const hard = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+          /* ignore */
+        }
+        setTimeout(done, 500); // give the OS a beat, then proceed regardless
+      }, 4000);
+      proc.once("exit", done);
+      try {
+        proc.kill();
+      } catch {
+        done();
+      }
+    });
+  }
+
   // ── JSON-RPC plumbing ──────────────────────────────────────────────────────
 
   private request(method: string, params: unknown): Promise<unknown> {