kiro-telegram-bot 1.5.1

package/src/index.ts

@@ -0,0 +1,74 @@
+/**
+ * Kiro Telegram Bot — entry point.
+ * Spawns the Kiro ACP agent, starts the Telegram bot, and wires graceful
+ * shutdown between them.
+ */
+import { AcpClient } from "./acp/client.js";
+import { createBot } from "./bot/bot.js";
+import { loadConfig } from "./config.js";
+import { createLogger, enableFileLogging, setLogLevel } from "./logger.js";
+
+async function main(): Promise<void> {
+  // Immediate feedback before any async work, so `npm start` shows life at once.
+  process.stdout.write("\u{1F916} Kiro Telegram Bot — starting…\n");
+
+  const cfg = loadConfig();
+  setLogLevel(cfg.logLevel);
+  enableFileLogging(cfg.logFile);
+  const log = createLogger("main");
+
+  log.info("starting Kiro Telegram Bot");
+  log.info(`workspace: ${cfg.workspace}`);
+  log.info(`kiro-cli:  ${cfg.kiroCliPath}`);
+  log.info(`log file:  ${cfg.logFile}`);
+
+  const acp = new AcpClient({
+    kiroCliPath: cfg.kiroCliPath,
+    workspace: cfg.workspace,
+    trustAllTools: cfg.trustAllTools,
+    agent: cfg.agent,
+    autoRestart: cfg.acpAutoRestart,
+    promptIdleTimeoutMs: cfg.promptIdleMs,
+  });
+
+  await acp.start();
+  const { bot, registry, scheduler } = await createBot(cfg, acp);
+  scheduler.start();
+
+  let shuttingDown = false;
+  const shutdown = (code: number): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log.info("shutting down…");
+    scheduler.stop();
+    registry.disposeAll();
+    void bot.stop().catch(() => {});
+    acp.stop();
+    setTimeout(() => process.exit(code), 500);
+  };
+
+  acp.on("exit", () => {
+    if (!cfg.acpAutoRestart) {
+      log.error("kiro-cli ACP exited and auto-restart is off — stopping bot.");
+      shutdown(1);
+    }
+  });
+  acp.on("restarted", () => log.info("ACP agent restarted; sessions will re-bind on next message."));
+
+  process.on("SIGINT", () => shutdown(0));
+  process.on("SIGTERM", () => shutdown(0));
+  process.on("uncaughtException", (err) => log.error("uncaughtException:", err));
+  process.on("unhandledRejection", (err) => log.error("unhandledRejection:", err));
+
+  await bot.start({
+    onStart: (info) => {
+      log.info(`bot online as @${info.username}`);
+      process.stdout.write(`\u2705 Online as @${info.username}. Send it a message on Telegram.\n`);
+    },
+  });
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/src/logger.ts

@@ -0,0 +1,78 @@
+/**
+ * Tiny leveled logger with timestamps and optional file output (for daemon
+ * mode, where stdout may not be captured).
+ */
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+
+const LEVELS = { debug: 10, info: 20, warn: 30, error: 40 } as const;
+export type LogLevel = keyof typeof LEVELS;
+
+let threshold: number = LEVELS.info;
+let filePath: string | undefined;
+
+const MAX_LOG_BYTES = 5 * 1024 * 1024; // rotate when the log file exceeds 5 MB
+
+export function setLogLevel(level: string | undefined): void {
+  const lvl = (level || "info").toLowerCase() as LogLevel;
+  threshold = LEVELS[lvl] ?? LEVELS.info;
+}
+
+/** Mirror all log output to a file (rotated once at startup if too large). */
+export function enableFileLogging(path: string): void {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    try {
+      if (statSync(path).size > MAX_LOG_BYTES) renameSync(path, `${path}.old`);
+    } catch {
+      /* no existing file */
+    }
+    filePath = path;
+  } catch {
+    filePath = undefined;
+  }
+}
+
+function ts(): string {
+  return new Date().toISOString().replace("T", " ").replace("Z", "");
+}
+
+function emit(level: LogLevel, scope: string, args: unknown[]): void {
+  if (LEVELS[level] < threshold) return;
+  const tag = `${ts()} ${level.toUpperCase().padEnd(5)} [${scope}]`;
+  const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  fn(tag, ...args);
+  if (filePath) {
+    try {
+      appendFileSync(filePath, `${tag} ${args.map(stringify).join(" ")}\n`);
+    } catch {
+      /* non-fatal */
+    }
+  }
+}
+
+function stringify(v: unknown): string {
+  if (typeof v === "string") return v;
+  if (v instanceof Error) return v.stack || v.message;
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+export interface Logger {
+  debug: (...a: unknown[]) => void;
+  info: (...a: unknown[]) => void;
+  warn: (...a: unknown[]) => void;
+  error: (...a: unknown[]) => void;
+}
+
+export function createLogger(scope: string): Logger {
+  return {
+    debug: (...a) => emit("debug", scope, a),
+    info: (...a) => emit("info", scope, a),
+    warn: (...a) => emit("warn", scope, a),
+    error: (...a) => emit("error", scope, a),
+  };
+}

package/src/mcp/config.ts

@@ -0,0 +1,103 @@
+/**
+ * MCP config store — reads and edits Kiro's `mcp.json` files.
+ *
+ * Sources, in precedence order for display (a workspace entry shadows a global
+ * one with the same name, mirroring how Kiro merges them):
+ *   • global    → `~/.kiro/settings/mcp.json`
+ *   • workspace → `<cwd>/.kiro/settings/mcp.json`
+ *
+ * Edits are surgical: we parse the file, flip a single `disabled` flag, and
+ * write it back with 2-space indentation, preserving every other field.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import { detailOf, type McpScope, type McpServer, type McpServerConfig, transportOf } from "./types.js";
+
+const log = createLogger("mcp:config");
+
+interface McpFile {
+  mcpServers?: Record<string, McpServerConfig>;
+  [k: string]: unknown;
+}
+
+/** Absolute path of the global mcp.json. */
+export function globalMcpPath(): string {
+  return join(homedir(), ".kiro", "settings", "mcp.json");
+}
+
+/** Absolute path of a workspace mcp.json for a given project directory. */
+export function workspaceMcpPath(cwd: string): string {
+  return join(cwd, ".kiro", "settings", "mcp.json");
+}
+
+function readFile(path: string): McpFile | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as McpFile;
+  } catch (e) {
+    log.warn(`cannot parse ${path}: ${(e as Error).message}`);
+    return undefined;
+  }
+}
+
+function serversFrom(path: string, scope: McpScope): McpServer[] {
+  const file = readFile(path);
+  const map = file?.mcpServers;
+  if (!map || typeof map !== "object") return [];
+  return Object.entries(map).map(([name, config]) => ({
+    name,
+    scope,
+    configPath: path,
+    disabled: config?.disabled === true,
+    transport: transportOf(config ?? {}),
+    detail: detailOf(config ?? {}),
+    config: config ?? {},
+  }));
+}
+
+/**
+ * List all configured MCP servers. Workspace entries shadow global ones with
+ * the same name. Returns them sorted by name (case-insensitive).
+ */
+export function listMcpServers(cwd?: string): McpServer[] {
+  const byName = new Map<string, McpServer>();
+  for (const s of serversFrom(globalMcpPath(), "global")) byName.set(s.name, s);
+  if (cwd) {
+    for (const s of serversFrom(workspaceMcpPath(cwd), "workspace")) byName.set(s.name, s);
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
+}
+
+/** Locate a single server by name (workspace shadows global). */
+export function findMcpServer(name: string, cwd?: string): McpServer | undefined {
+  return listMcpServers(cwd).find((s) => s.name === name);
+}
+
+export interface ToggleResult {
+  ok: boolean;
+  /** New disabled state on success. */
+  disabled?: boolean;
+  error?: string;
+}
+
+/**
+ * Set the `disabled` flag for a server in its own config file. The change takes
+ * effect when the agent next (re)loads servers (after `/restart` / new session).
+ */
+export function setMcpDisabled(server: McpServer, disabled: boolean): ToggleResult {
+  const file = readFile(server.configPath);
+  if (!file || !file.mcpServers || !file.mcpServers[server.name]) {
+    return { ok: false, error: `server "${server.name}" not found in ${server.configPath}` };
+  }
+  const entry = file.mcpServers[server.name]!;
+  if (disabled) entry.disabled = true;
+  else delete entry.disabled; // absence === enabled; keeps the file clean
+  try {
+    writeFileSync(server.configPath, JSON.stringify(file, null, 2) + "\n", "utf-8");
+    return { ok: true, disabled };
+  } catch (e) {
+    return { ok: false, error: (e as Error).message };
+  }
+}

package/src/mcp/probe.ts

@@ -0,0 +1,218 @@
+/**
+ * MCP health probe — performs a real MCP `initialize` JSON-RPC handshake against
+ * a configured server to determine whether it actually connects, and why not.
+ *
+ *   • stdio servers → spawn the command (args/env), write `initialize` to stdin,
+ *     await a matching JSON-RPC response on stdout, then kill the process.
+ *   • http servers  → POST `initialize` to the URL (with headers); accept either
+ *     a JSON body or an SSE `data:` line (Streamable HTTP transport).
+ *
+ * This mirrors exactly what an MCP client does on connect, so a success means
+ * the server is reachable and speaks MCP; a failure carries the real reason
+ * (command not found, timeout, HTTP status, transport error, …).
+ */
+import { spawn } from "node:child_process";
+import { createLogger } from "../logger.js";
+import type { McpProbeResult, McpServer } from "./types.js";
+
+const log = createLogger("mcp:probe");
+
+const INIT_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-11-05",
+    capabilities: {},
+    clientInfo: { name: "kiro-telegram-bot", version: "1.0.0" },
+  },
+};
+
+export interface ProbeOptions {
+  timeoutMs: number;
+  concurrency: number;
+}
+
+/** Probe a single server. Never throws — failures are returned as results. */
+export async function probeServer(server: McpServer, timeoutMs: number): Promise<McpProbeResult> {
+  if (server.disabled) return { name: server.name, ok: false, skipped: true, error: "disabled" };
+  const start = Date.now();
+  try {
+    const info = server.transport === "http" ? await probeHttp(server, timeoutMs) : await probeStdio(server, timeoutMs);
+    return { name: server.name, ok: true, ms: Date.now() - start, serverName: info.name, serverVersion: info.version };
+  } catch (e) {
+    return { name: server.name, ok: false, ms: Date.now() - start, error: (e as Error).message };
+  }
+}
+
+/** Probe many servers with bounded concurrency. Disabled servers are skipped. */
+export async function probeAll(
+  servers: McpServer[],
+  opts: ProbeOptions,
+  onResult?: (r: McpProbeResult, done: number, total: number) => void,
+): Promise<McpProbeResult[]> {
+  const results: McpProbeResult[] = new Array(servers.length);
+  let next = 0;
+  let done = 0;
+  const total = servers.length;
+  const worker = async (): Promise<void> => {
+    for (;;) {
+      const i = next++;
+      if (i >= servers.length) return;
+      const r = await probeServer(servers[i]!, opts.timeoutMs);
+      results[i] = r;
+      done++;
+      try {
+        onResult?.(r, done, total);
+      } catch {
+        /* non-fatal */
+      }
+    }
+  };
+  const workers = Array.from({ length: Math.max(1, Math.min(opts.concurrency, servers.length)) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+interface ServerIdent {
+  name?: string;
+  version?: string;
+}
+
+function identFrom(result: unknown): ServerIdent {
+  const r = result as { serverInfo?: { name?: string; version?: string } };
+  return { name: r?.serverInfo?.name, version: r?.serverInfo?.version };
+}
+
+/** stdio handshake: spawn, send initialize, await a JSON-RPC response. */
+function probeStdio(server: McpServer, timeoutMs: number): Promise<ServerIdent> {
+  return new Promise<ServerIdent>((resolve, reject) => {
+    const cmd = server.config.command;
+    if (!cmd) return reject(new Error("no command configured"));
+    const args = Array.isArray(server.config.args) ? server.config.args.map(String) : [];
+    let settled = false;
+    let proc: ReturnType<typeof spawn>;
+    try {
+      proc = spawn(cmd, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...(server.config.env ?? {}) },
+        windowsHide: true,
+      });
+    } catch (e) {
+      return reject(new Error(`spawn failed: ${(e as Error).message}`));
+    }
+
+    const finish = (err?: Error, ident?: ServerIdent): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        proc.kill();
+      } catch {
+        /* ignore */
+      }
+      if (err) reject(err);
+      else resolve(ident ?? {});
+    };
+
+    const timer = setTimeout(() => finish(new Error(`timeout after ${timeoutMs}ms (no response)`)), timeoutMs);
+
+    let stderrTail = "";
+    let buf = "";
+    proc.stdout?.setEncoding("utf-8");
+    proc.stdout?.on("data", (chunk: string) => {
+      buf += chunk;
+      let i: number;
+      while ((i = buf.indexOf("\n")) !== -1) {
+        const line = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (!line) continue;
+        try {
+          const m = JSON.parse(line) as { id?: unknown; result?: unknown; error?: { message?: string } };
+          if (m && m.id === 1) {
+            if (m.error) finish(new Error(`server error: ${m.error.message ?? "unknown"}`));
+            else finish(undefined, identFrom(m.result));
+            return;
+          }
+        } catch {
+          /* partial / non-JSON banner line — keep reading */
+        }
+      }
+    });
+    proc.stderr?.setEncoding("utf-8");
+    proc.stderr?.on("data", (c: string) => {
+      stderrTail = (stderrTail + c).slice(-300);
+    });
+    proc.on("error", (e) => finish(new Error(`spawn failed: ${e.message}`)));
+    proc.on("exit", (code) => {
+      if (!settled) {
+        const tail = stderrTail.trim() ? ` — ${stderrTail.trim().split("\n").pop()}` : "";
+        finish(new Error(`process exited (code ${code})${tail}`));
+      }
+    });
+
+    try {
+      proc.stdin?.write(JSON.stringify(INIT_REQUEST) + "\n");
+    } catch (e) {
+      finish(new Error(`write failed: ${(e as Error).message}`));
+    }
+  });
+}
+
+/** HTTP handshake: POST initialize; parse JSON or an SSE `data:` payload. */
+async function probeHttp(server: McpServer, timeoutMs: number): Promise<ServerIdent> {
+  const url = server.config.url!;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        ...(server.config.headers ?? {}),
+      },
+      body: JSON.stringify(INIT_REQUEST),
+      signal: controller.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`.trim());
+    const text = await res.text();
+    const parsed = parseJsonOrSse(text);
+    if (!parsed) throw new Error("no JSON-RPC result in response");
+    if (parsed.error) throw new Error(`server error: ${parsed.error.message ?? "unknown"}`);
+    return identFrom(parsed.result);
+  } catch (e) {
+    const msg = (e as Error).name === "AbortError" ? `timeout after ${timeoutMs}ms` : (e as Error).message;
+    throw new Error(msg);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+interface RpcEnvelope {
+  result?: unknown;
+  error?: { message?: string };
+}
+
+/** Accept a plain JSON body or SSE frames (`event: …\n data: {json}`). */
+function parseJsonOrSse(text: string): RpcEnvelope | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  try {
+    return JSON.parse(trimmed) as RpcEnvelope;
+  } catch {
+    /* maybe SSE */
+  }
+  for (const line of trimmed.split("\n")) {
+    const m = /^data:\s*(.+)$/.exec(line.trim());
+    if (m) {
+      try {
+        return JSON.parse(m[1]!) as RpcEnvelope;
+      } catch {
+        /* keep scanning */
+      }
+    }
+  }
+  log.debug("unparseable MCP HTTP response:", trimmed.slice(0, 120));
+  return undefined;
+}

package/src/mcp/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Types for MCP (Model Context Protocol) server inspection & control.
+ *
+ * Kiro CLI loads MCP servers from JSON config files: a global one at
+ * `~/.kiro/settings/mcp.json` (the "default" scope used by the default agent)
+ * and an optional per-workspace `<cwd>/.kiro/settings/mcp.json`. Each server may
+ * carry a `disabled` flag; toggling it enables/disables the server (applied the
+ * next time the agent (re)loads — i.e. after `/restart` or a new session).
+ */
+
+export type McpScope = "global" | "workspace";
+export type McpTransport = "http" | "stdio" | "unknown";
+
+/** Raw server definition as stored in an mcp.json `mcpServers` entry. */
+export interface McpServerConfig {
+  command?: string;
+  args?: string[];
+  url?: string;
+  headers?: Record<string, string>;
+  env?: Record<string, string>;
+  timeout?: number;
+  disabled?: boolean;
+  autoApprove?: string[];
+  [k: string]: unknown;
+}
+
+/** A configured server resolved from a specific config file. */
+export interface McpServer {
+  name: string;
+  scope: McpScope;
+  /** Absolute path of the config file this server is defined in. */
+  configPath: string;
+  disabled: boolean;
+  transport: McpTransport;
+  /** Short transport descriptor for display (command or url, trimmed). */
+  detail: string;
+  config: McpServerConfig;
+}
+
+/** Result of a live connection probe (MCP `initialize` handshake). */
+export interface McpProbeResult {
+  name: string;
+  ok: boolean;
+  /** Round-trip time in ms when ok. */
+  ms?: number;
+  /** Server-reported name/version when ok. */
+  serverName?: string;
+  serverVersion?: string;
+  /** Human-readable failure reason when not ok. */
+  error?: string;
+  /** True when the server was skipped because it is disabled. */
+  skipped?: boolean;
+}
+
+export function transportOf(c: McpServerConfig): McpTransport {
+  if (typeof c.url === "string" && c.url.trim()) return "http";
+  if (typeof c.command === "string" && c.command.trim()) return "stdio";
+  return "unknown";
+}
+
+export function detailOf(c: McpServerConfig): string {
+  if (typeof c.url === "string" && c.url.trim()) return c.url.trim();
+  if (typeof c.command === "string" && c.command.trim()) {
+    const args = Array.isArray(c.args) && c.args.length ? " " + c.args.join(" ") : "";
+    return (c.command + args).trim();
+  }
+  return "(no command/url)";
+}

package/src/projects/manager.ts

@@ -0,0 +1,88 @@
+/**
+ * Project manager — discovers candidate project directories under the
+ * configured roots, de-duplicated by name, with search and create helpers.
+ */
+import { mkdirSync, readdirSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("projects");
+
+const IGNORE = new Set([
+  "node_modules",
+  ".git",
+  ".history",
+  "dist",
+  "build",
+  "out",
+  ".cache",
+  "target",
+  ".venv",
+  "__pycache__",
+]);
+
+export interface ProjectEntry {
+  name: string;
+  path: string;
+}
+
+export class ProjectManager {
+  constructor(private readonly roots: string[]) {}
+
+  /** List projects, de-duplicated by (case-insensitive) name. */
+  list(limit = 100): ProjectEntry[] {
+    const byName = new Map<string, ProjectEntry>();
+
+    for (const root of this.roots) {
+      let children: string[];
+      try {
+        children = readdirSync(root);
+      } catch (e) {
+        log.debug(`cannot read root ${root}:`, (e as Error).message);
+        continue;
+      }
+      for (const child of children) {
+        if (IGNORE.has(child) || child.startsWith(".")) continue;
+        const full = join(root, child);
+        try {
+          if (!statSync(full).isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        const key = child.toLowerCase();
+        if (!byName.has(key)) byName.set(key, { name: child, path: full });
+      }
+    }
+
+    const out = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+    return out.slice(0, limit);
+  }
+
+  /** Projects whose name contains the query (case-insensitive). */
+  search(query: string, limit = 100): ProjectEntry[] {
+    const q = query.trim().toLowerCase();
+    if (!q) return this.list(limit);
+    return this.list(1000)
+      .filter((p) => p.name.toLowerCase().includes(q))
+      .slice(0, limit);
+  }
+
+  /** Create a new project folder under the first root and return it. */
+  create(name: string): ProjectEntry {
+    const clean = name.trim().replace(/[<>:"/\\|?*]/g, "_");
+    if (!clean) throw new Error("Invalid project name.");
+    const root = this.roots[0];
+    if (!root) throw new Error("No project root configured (set PROJECT_ROOTS).");
+    const full = join(root, clean);
+    mkdirSync(full, { recursive: true });
+    return { name: clean, path: full };
+  }
+
+  isDirectory(path: string): boolean {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}

package/src/render/chunk.ts

@@ -0,0 +1,57 @@
+/**
+ * Split a MarkdownV2 string into Telegram-sized chunks (<= 4096 chars) without
+ * breaking code fences. If a split happens inside a ``` block, the block is
+ * closed before the boundary and reopened in the next chunk.
+ */
+const LIMIT = 4000; // headroom under Telegram's 4096 hard limit
+
+export function chunkMarkdown(text: string, limit = LIMIT): string[] {
+  if (text.length <= limit) return text.length ? [text] : [];
+
+  const lines = text.split("\n");
+  const chunks: string[] = [];
+  let current: string[] = [];
+  let size = 0;
+  let fenceLang: string | null = null; // non-null => currently inside a fence
+
+  const flush = (): void => {
+    if (current.length === 0) return;
+    let body = current.join("\n");
+    if (fenceLang !== null) body += "\n```"; // close dangling fence
+    chunks.push(body);
+    current = [];
+    size = 0;
+    if (fenceLang !== null) {
+      // Reopen the fence at the top of the next chunk.
+      const reopen = "```" + fenceLang;
+      current.push(reopen);
+      size = reopen.length + 1;
+    }
+  };
+
+  for (const rawLine of lines) {
+    const line = rawLine;
+    const fenceMatch = /^```(.*)$/.exec(line);
+
+    // Hard-split a single oversized line.
+    if (line.length + 1 > limit && fenceMatch === null) {
+      flush();
+      for (let i = 0; i < line.length; i += limit) {
+        chunks.push(line.slice(i, i + limit));
+      }
+      continue;
+    }
+
+    if (size + line.length + 1 > limit) flush();
+
+    current.push(line);
+    size += line.length + 1;
+
+    if (fenceMatch) {
+      fenceLang = fenceLang === null ? (fenceMatch[1] ?? "").trim() : null;
+    }
+  }
+
+  flush();
+  return chunks.filter((c) => c.trim().length > 0);
+}