kiro-telegram-bot 1.6.0 → 1.7.2

package/src/acp/client.ts

@@ -29,7 +29,7 @@ const log = createLogger("acp:client");
 /** JSON-RPC error codes that usually mean "transient backend hiccup". */
 const TRANSIENT_CODES = new Set([-32603, -32500, -32000, 500, 502, 503, 504, 429]);
 const TRANSIENT_RE =
-  /internal error|high volume|experiencing|overloaded|temporar|unavailable|rate.?limit|too many requests|try again|capacity|\b50[234]\b|\b429\b/i;
+  /internal error|high volume|experiencing|overloaded|temporar|unavailable|rate.?limit|too many requests|try again|capacity|dispatch failure|response stream|connection (?:reset|closed|refused|error)|reset by peer|broken pipe|socket hang ?up|econnreset|econnrefused|enotfound|eai_again|etimedout|\b50[234]\b|\b429\b/i;
 
 /** Error that preserves the agent's JSON-RPC error code and data payload. */
 export class AcpError extends Error {
@@ -120,6 +120,12 @@ export class AcpClient extends EventEmitter {
   private readonly promptMaxMs: number;
   /** Last time we saw streaming activity for a session (epoch ms). */
   private readonly lastActivity = new Map<string, number>();
+  /** Last time ANY session OR subagent produced output (epoch ms) — a
+   *  process-wide "the agent is alive" clock. The per-session map misses work
+   *  done by subagents (they stream on their own session ids), so without this
+   *  a prompt that delegates to long-running subagents (e.g. parallel
+   *  translation) trips the idle timeout while its subagents are doing the work. */
+  private lastActivityAny = 0;
   private stopped = false;
   private restartAttempts = 0;
   private restartTimer?: NodeJS.Timeout;
@@ -159,24 +165,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", {
@@ -276,15 +289,21 @@ export class AcpClient extends EventEmitter {
       const start = Date.now();
       this.lastActivity.set(sessionId, start);
       const watch = setInterval(() => {
-        const idle = Date.now() - (this.lastActivity.get(sessionId) ?? start);
+        // Count activity from ANY session/subagent (the process-wide clock), so
+        // a turn that's delegating to long-running subagents stays alive while
+        // they work — only a genuinely silent (stuck) agent trips the timeout.
+        const last = Math.max(this.lastActivity.get(sessionId) ?? start, this.lastActivityAny);
+        const idle = Date.now() - last;
         const total = Date.now() - start;
         if (total > this.promptMaxMs) {
           this.pending.delete(id);
           clearInterval(watch);
+          void this.cancel(sessionId); // stop the runaway turn so the session is reusable
           reject(new Error(`Prompt exceeded the ${Math.round(this.promptMaxMs / 60_000)}min cap`));
         } else if (idle > this.promptIdleMs) {
           this.pending.delete(id);
           clearInterval(watch);
+          void this.cancel(sessionId); // free the session — otherwise the next prompt collides ("dispatch failure")
           reject(new Error(`No agent activity for ${Math.round(idle / 1000)}s — giving up`));
         }
       }, 15_000);
@@ -329,22 +348,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> {
@@ -424,6 +508,17 @@ export class AcpClient extends EventEmitter {
   }
 
   private routeNotification(method: string, params: unknown): void {
+    // Any agent-work notification — the main stream, a SUBAGENT's stream, model
+    // metadata, or a subagent status change — proves the process is alive, so
+    // refresh the process-wide clock. This is what keeps a prompt delegating to
+    // long-running subagents from tripping the per-session idle timeout.
+    if (
+      method === "session/update" ||
+      method === "_kiro.dev/metadata" ||
+      method === "_kiro.dev/subagent/list_update"
+    ) {
+      this.lastActivityAny = Date.now();
+    }
     if (method === "session/update") {
       const p = params as SessionNotificationParams;
       if (p?.sessionId && p.update) {

package/src/app/auth-service.ts

@@ -0,0 +1,325 @@
+/**
+ * Kiro authentication control for /reauth: `kiro-cli logout` then an interactive
+ * `kiro-cli login --use-device-flow`. The device flow prints a verification URL
+ * + code to stdout (no browser redirect on the bot host), which we stream back
+ * to Telegram so the user can complete it on their own device.
+ */
+import { execFile, spawn } from "node:child_process";
+import { rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { createLogger } from "../logger.js";
+
+const run = promisify(execFile);
+const log = createLogger("auth");
+
+// Strip ANSI colour/cursor escapes so the Telegram transcript stays readable.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+export interface LoginResult {
+  ok: boolean;
+  code: number | null;
+  /** True when the login was aborted via the supplied AbortSignal. */
+  cancelled?: boolean;
+  /** Human-readable failure reason, when known (shown in the chat). */
+  error?: string;
+}
+
+export interface LoginOptions {
+  /** Extra CLI flags (e.g. `--license pro`). `--use-device-flow` is added if absent. */
+  extraArgs?: string[];
+  /** Receives decoded stdout/stderr chunks as they arrive. */
+  onOutput: (text: string) => void;
+  /** Overall timeout before the login process is killed (default 5 min). */
+  timeoutMs?: number;
+  /** Abort to cancel the in-flight login — kills the process (Cancel button). */
+  signal?: AbortSignal;
+}
+
+export interface IdcLoginOptions {
+  /** IAM Identity Center start URL (e.g. https://my-org.awsapps.com/start). */
+  startUrl: string;
+  /** AWS region of the Identity Center (e.g. us-east-1). */
+  region: string;
+  /** Receives decoded output chunks as they arrive. */
+  onOutput: (text: string) => void;
+  /** Overall timeout before the login process is killed (default 5 min). */
+  timeoutMs?: number;
+  /** Abort to cancel the in-flight login — kills the process (Cancel button). */
+  signal?: AbortSignal;
+}
+
+/** Minimal shape of the optional `node-pty` module we rely on. */
+interface IPty {
+  onData(cb: (data: string) => void): void;
+  onExit(cb: (e: { exitCode: number; signal?: number }) => void): void;
+  write(data: string): void;
+  kill(signal?: string): void;
+}
+interface PtyModule {
+  spawn(
+    file: string,
+    args: string[],
+    options: { name?: string; cols?: number; rows?: number; cwd?: string; env?: NodeJS.ProcessEnv },
+  ): IPty;
+}
+
+export class AuthService {
+  constructor(private readonly kiroCliPath: string) {}
+
+  /** Run `kiro-cli logout` (non-interactive). */
+  async logout(): Promise<{ ok: boolean; out: string }> {
+    try {
+      const { stdout, stderr } = await run(this.kiroCliPath, ["logout"], {
+        timeout: 30_000,
+        encoding: "utf-8",
+      });
+      return { ok: true, out: clean(`${stdout}${stderr}`) };
+    } catch (e) {
+      const err = e as { stdout?: string; stderr?: string; message?: string };
+      const out = clean(`${err.stdout ?? ""}${err.stderr ?? ""}`) || err.message || "logout failed";
+      return { ok: false, out };
+    }
+  }
+
+  /**
+   * Best-effort removal of Kiro's cached auth token (`~/.aws/sso/cache/
+   * kiro-auth-token.json`) — the file that carries the logged-in identity
+   * (accessToken + refreshToken). Removing it after `logout` guarantees the
+   * next `login` performs a genuine device-flow authentication instead of
+   * silently reusing the previous account's cached/refreshable token.
+   *
+   * Surgical and safe: it touches ONLY Kiro's own token file, never the shared,
+   * account-agnostic OIDC client registrations, and is a no-op if absent.
+   */
+  async clearTokenCache(): Promise<boolean> {
+    const path = join(homedir(), ".aws", "sso", "cache", "kiro-auth-token.json");
+    try {
+      await rm(path, { force: true });
+      log.info(`cleared cached auth token (${path})`);
+      return true;
+    } catch (e) {
+      log.debug("clearTokenCache failed:", (e as Error).message);
+      return false;
+    }
+  }
+
+  /**
+   * to `onOutput` as it arrives (so the device code/URL reaches the user fast).
+   * Resolves when the process exits, the timeout fires, or the signal aborts.
+   */
+  login(opts: LoginOptions): Promise<LoginResult> {
+    const { extraArgs = [], onOutput, timeoutMs = 300_000, signal } = opts;
+    return new Promise<LoginResult>((resolve) => {
+      if (signal?.aborted) {
+        resolve({ ok: false, code: null, cancelled: true });
+        return;
+      }
+      const args = ["login"];
+      if (!extraArgs.includes("--use-device-flow")) args.push("--use-device-flow");
+      args.push(...extraArgs);
+      log.info(`spawning login: ${this.kiroCliPath} ${args.join(" ")}`);
+
+      let proc;
+      try {
+        // stdin ignored: any interactive prompt gets EOF rather than hanging.
+        proc = spawn(this.kiroCliPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+      } catch (e) {
+        onOutput(`error: ${(e as Error).message}`);
+        resolve({ ok: false, code: null });
+        return;
+      }
+
+      let cancelled = false;
+      let settled = false;
+      let hardKill: NodeJS.Timeout | undefined;
+
+      const onAbort = (): void => {
+        cancelled = true;
+        try {
+          proc.kill();
+        } catch {
+          /* ignore */
+        }
+        // Escalate if the CLI ignores the polite signal.
+        hardKill = setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+            /* ignore */
+          }
+        }, 2000);
+      };
+
+      const finish = (r: LoginResult): void => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (hardKill) clearTimeout(hardKill);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(r);
+      };
+
+      const feed = (b: Buffer): void => {
+        const t = clean(b.toString("utf-8"));
+        if (t) onOutput(t);
+      };
+      proc.stdout.on("data", feed);
+      proc.stderr.on("data", feed);
+
+      const timer = setTimeout(() => {
+        onOutput("\n\u23F1\uFE0F Timed out waiting for login to complete.");
+        try {
+          proc.kill();
+        } catch {
+          /* ignore */
+        }
+      }, timeoutMs);
+
+      signal?.addEventListener("abort", onAbort, { once: true });
+
+      proc.on("error", (e: Error) => {
+        onOutput(`error: ${e.message}`);
+        finish({ ok: false, code: null, cancelled });
+      });
+      proc.on("exit", (code: number | null) => {
+        finish({ ok: code === 0 && !cancelled, code, cancelled });
+      });
+    });
+  }
+
+  /**
+   * IAM Identity Center (Pro) login. Unlike the Builder ID device flow, this
+   * CLI path is *interactive*: it always prompts ("Enter Start URL", "Enter
+   * Region", and — when the account has several — an Identity Center profile
+   * picker) and refuses to run without a real terminal. So we drive it inside a
+   * pseudo-terminal (the optional `node-pty` module), answering each prompt with
+   * the start URL / region the user supplied and accepting the default profile.
+   * The device verification URL + code still stream out via `onOutput`.
+   */
+  loginIdc(opts: IdcLoginOptions): Promise<LoginResult> {
+    const { startUrl, region, onOutput, timeoutMs = 300_000, signal } = opts;
+    return new Promise<LoginResult>((resolve) => {
+      if (signal?.aborted) {
+        resolve({ ok: false, code: null, cancelled: true });
+        return;
+      }
+      void (async () => {
+        // Load the optional native PTY lazily via a variable specifier so a
+        // missing module is a graceful runtime error, not an install/type break.
+        let pty: PtyModule;
+        try {
+          const specifier = "@homebridge/node-pty-prebuilt-multiarch";
+          const mod = (await import(specifier)) as unknown as PtyModule & { default?: PtyModule };
+          pty = typeof mod.spawn === "function" ? mod : (mod.default as PtyModule);
+          if (!pty || typeof pty.spawn !== "function") throw new Error("invalid pty module");
+        } catch {
+          resolve({
+            ok: false,
+            code: null,
+            error:
+              "IAM Identity Center login needs the PTY module. Run `npm install` in the bot folder, then try again.",
+          });
+          return;
+        }
+
+        // Pass the start URL + region as flags so the interactive prompts come
+        // PREFILLED — we then just press Enter to accept them. Typing the values
+        // ourselves makes the terminal echo them, which doubles the captured
+        // input (e.g. "us-east-1us-east-1" → bad OIDC endpoint). Q_FAKE_IS_REMOTE
+        // forces the CLI to PRINT the verification URL instead of opening a
+        // browser on the bot host, so it streams to Telegram.
+        const args = [
+          "login",
+          "--license",
+          "pro",
+          "--identity-provider",
+          startUrl,
+          "--region",
+          region,
+          "--use-device-flow",
+        ];
+        log.info(`spawning IDC login (pty): ${this.kiroCliPath} ${args.join(" ")}`);
+
+        let term: IPty;
+        try {
+          term = pty.spawn(this.kiroCliPath, args, {
+            name: "xterm-color",
+            cols: 120,
+            rows: 30,
+            env: { ...process.env, Q_FAKE_IS_REMOTE: "1" },
+          });
+        } catch (e) {
+          resolve({ ok: false, code: null, error: (e as Error).message });
+          return;
+        }
+
+        let buf = "";
+        let sentUrl = false;
+        let sentRegion = false;
+        let sentProfile = false;
+        let cancelled = false;
+        let settled = false;
+
+        const onAbort = (): void => {
+          cancelled = true;
+          try {
+            term.kill();
+          } catch {
+            /* ignore */
+          }
+        };
+
+        const finish = (r: LoginResult): void => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+          try {
+            term.kill();
+          } catch {
+            /* ignore */
+          }
+          resolve(r);
+        };
+
+        const timer = setTimeout(() => {
+          onOutput("\n\u23F1\uFE0F Timed out waiting for login to complete.");
+          try {
+            term.kill();
+          } catch {
+            /* ignore */
+          }
+        }, timeoutMs);
+
+        signal?.addEventListener("abort", onAbort, { once: true });
+
+        term.onData((d: string) => {
+          const t = clean(d);
+          if (t) onOutput(t);
+          buf += t;
+          // Each prompt is PREFILLED (from the flags); just press Enter to accept
+          // it. We answer each exactly once, in order.
+          if (!sentUrl && /start url/i.test(buf)) {
+            sentUrl = true;
+            term.write("\r");
+          } else if (sentUrl && !sentRegion && /enter region/i.test(buf)) {
+            sentRegion = true;
+            term.write("\r");
+          } else if (sentRegion && !sentProfile && /select an iam identity center profile/i.test(buf)) {
+            sentProfile = true;
+            term.write("\r"); // accept the default (first) profile
+          }
+        });
+
+        term.onExit(({ exitCode }) => finish({ ok: exitCode === 0 && !cancelled, code: exitCode, cancelled }));
+      })();
+    });
+  }
+}
+
+function clean(s: string): string {
+  return s.replace(ANSI_RE, "").replace(/\r/g, "");
+}

package/src/app/instance-lock.ts

@@ -0,0 +1,139 @@
+/**
+ * Single-instance guard, keyed per bot token (NOT per folder), so the same bot
+ * can't run twice no matter which directory it's started from.
+ *
+ * Telegram allows only ONE long-polling consumer per token — a second instance
+ * triggers 409 Conflict and, worse, a leftover "ghost" process started from an
+ * old folder keeps answering with a stale `.env` (e.g. an outdated
+ * `ALLOWED_USERS`, so you get "⛔ Not authorized"). On startup we therefore
+ * take an exclusive lock: if a still-alive instance holds it, we terminate that
+ * process (and its child tree on Windows) so the fresh process — with the
+ * current config — becomes the only consumer.
+ *
+ * The lock lives under the canonical home (`~/.kiro/tg/locks/<tokenHash>.lock`)
+ * and stores only a pid + start time + whether the holder is supervised. The
+ * token itself is never written to disk (only its hash names the file).
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import { killPid } from "../sessions/process.js";
+import { isPidAlive } from "../sessions/store.js";
+
+const log = createLogger("lock");
+
+interface LockData {
+  pid: number;
+  startedAt: number;
+  /** True when the holder runs under a supervisor (systemd/launchd/Task). */
+  supervised: boolean;
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+export class InstanceLock {
+  private readonly file: string;
+  private held = false;
+
+  constructor(
+    token: string,
+    locksDir: string,
+    private readonly supervised: boolean,
+  ) {
+    const hash = createHash("sha256").update(token).digest("hex").slice(0, 16);
+    this.file = join(locksDir, `${hash}.lock`);
+  }
+
+  /**
+   * Become the sole instance for this token. Returns `false` (caller should
+   * exit) only when a *supervised* service instance is already running and this
+   * process is a plain manual start — we don't fight the background service
+   * (that would cause a restart/kill loop). Otherwise we take over: a live
+   * holder is terminated and the lock is rewritten with our pid.
+   */
+  async acquire(): Promise<boolean> {
+    const existing = this.read();
+    if (existing && existing.pid !== process.pid && isPidAlive(existing.pid)) {
+      if (existing.supervised && !this.supervised) {
+        log.warn(`a supervised service instance is already running (pid ${existing.pid}); not starting a duplicate`);
+        return false;
+      }
+      if (looksLikeNode(existing.pid)) {
+        log.warn(`another bot instance is running (pid ${existing.pid}); terminating it to take over`);
+        killPid(existing.pid);
+        for (let i = 0; i < 20 && isPidAlive(existing.pid); i++) await sleep(150); // up to ~3s
+        if (isPidAlive(existing.pid)) log.warn(`previous instance ${existing.pid} still alive after kill; continuing anyway`);
+      } else {
+        // The locked pid was recycled to an unrelated process — don't kill it,
+        // just reclaim the stale lock.
+        log.warn(`lock pid ${existing.pid} is not a node process; reclaiming stale lock`);
+      }
+    }
+    this.write();
+    this.held = true;
+    return true;
+  }
+
+  /** Release the lock if (and only if) we still own it. */
+  release(): void {
+    if (!this.held) return;
+    this.held = false;
+    try {
+      const cur = this.read();
+      if (cur?.pid === process.pid) rmSync(this.file, { force: true });
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  private write(): void {
+    const data: LockData = { pid: process.pid, startedAt: Date.now(), supervised: this.supervised };
+    try {
+      mkdirSync(join(this.file, ".."), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log.warn(`could not write lock file ${this.file}: ${(e as Error).message}`);
+    }
+  }
+
+  private read(): LockData | undefined {
+    try {
+      const d = JSON.parse(readFileSync(this.file, "utf-8")) as Partial<LockData>;
+      if (typeof d.pid === "number" && d.pid > 0) {
+        return { pid: d.pid, startedAt: Number(d.startedAt) || 0, supervised: Boolean(d.supervised) };
+      }
+    } catch {
+      /* no/invalid lock */
+    }
+    return undefined;
+  }
+}
+
+/**
+ * Best-effort check that `pid` is a node process (our bot), to avoid killing an
+ * unrelated process that happened to reuse the pid. If the platform query can't
+ * run or be parsed, we assume it's ours (only this bot writes the lock) — better
+ * to clear a ghost than to leave one fighting over the token.
+ */
+function looksLikeNode(pid: number): boolean {
+  try {
+    if (process.platform === "win32") {
+      const out = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      // No matching task prints an INFO line, not a CSV row — treat as "gone".
+      if (!/^\s*"/.test(out)) return false;
+      return /node\.exe|tsx/i.test(out);
+    }
+    const out = execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return /node|tsx/i.test(out);
+  } catch {
+    return true;
+  }
+}

package/src/bot/auth.ts

@@ -14,12 +14,23 @@ export function createAuthMiddleware(cfg: AppConfig) {
   }
 
   return async (ctx: Context, next: NextFunction): Promise<void> => {
-    const userId = ctx.from?.id ? String(ctx.from.id) : undefined;
-    if (allowAll || (userId && cfg.allowedUsers.has(userId))) {
+    const from = ctx.from;
+    // Only a genuine USER action is subject to (and worth replying to) the auth
+    // gate. Ignore everything else silently — most importantly the bot's OWN
+    // updates: the status panel being pinned/unpinned emits a service message
+    // whose `from` is THIS bot (is_bot), and replying "⛔ Not authorized" to
+    // that (or to any service/no-`from` update) spammed the chat with false
+    // rejections. Real unauthorized users still get one clear reply below.
+    if (!from || from.is_bot) return;
+    const m = ctx.message ?? ctx.editedMessage;
+    if (m && (m.pinned_message || m.new_chat_members || m.left_chat_member)) return;
+
+    const userId = String(from.id);
+    if (allowAll || cfg.allowedUsers.has(userId)) {
       await next();
       return;
     }
-    log.warn(`blocked unauthorized user ${userId ?? "unknown"}`);
+    log.warn(`blocked unauthorized user ${userId}`);
     if (ctx.chat) {
       await ctx.reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID.");
     }