kiro-telegram-bot 1.5.1

package/src/bot/telegram-io.ts

@@ -0,0 +1,109 @@
+/**
+ * Safe Telegram I/O: send/edit messages with MarkdownV2, automatically falling
+ * back to plain text on parse errors and retrying on rate limits (429).
+ */
+import { type Api, GrammyError } from "grammy";
+import { createLogger } from "../logger.js";
+import { chunkMarkdown } from "../render/chunk.js";
+import { toTelegramMarkdown } from "../render/markdown.js";
+
+const log = createLogger("tg:io");
+const MAX_RETRIES = 3;
+
+async function withRetry<T>(fn: () => Promise<T>): Promise<T> {
+  let attempt = 0;
+  for (;;) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (err instanceof GrammyError && err.error_code === 429) {
+        const wait = (err.parameters?.retry_after ?? 1) * 1000 + 250;
+        if (attempt++ < MAX_RETRIES) {
+          log.debug(`429 rate limited, waiting ${wait}ms`);
+          await sleep(wait);
+          continue;
+        }
+      }
+      throw err;
+    }
+  }
+}
+
+/** Send a message as MarkdownV2, falling back to plain text on parse errors. */
+export async function safeSend(
+  api: Api,
+  chatId: number,
+  markdownV2: string,
+  plain: string,
+  extra: Record<string, unknown> = {},
+): Promise<number | undefined> {
+  try {
+    const msg = await withRetry(() =>
+      api.sendMessage(chatId, markdownV2, { parse_mode: "MarkdownV2", ...extra }),
+    );
+    return msg.message_id;
+  } catch (err) {
+    if (isParseError(err)) {
+      const msg = await withRetry(() => api.sendMessage(chatId, plain, extra));
+      return msg.message_id;
+    }
+    log.warn("sendMessage failed:", (err as Error).message);
+    return undefined;
+  }
+}
+
+/** Edit a message as MarkdownV2, falling back to plain text on parse errors. */
+export async function safeEdit(
+  api: Api,
+  chatId: number,
+  messageId: number,
+  markdownV2: string,
+  plain: string,
+): Promise<void> {
+  try {
+    await withRetry(() =>
+      api.editMessageText(chatId, messageId, markdownV2, { parse_mode: "MarkdownV2" }),
+    );
+  } catch (err) {
+    if (isNotModified(err)) return;
+    if (isParseError(err)) {
+      try {
+        await withRetry(() => api.editMessageText(chatId, messageId, plain));
+      } catch (e2) {
+        if (!isNotModified(e2)) log.debug("plain edit failed:", (e2 as Error).message);
+      }
+      return;
+    }
+    log.debug("editMessageText failed:", (err as Error).message);
+  }
+}
+
+function isParseError(err: unknown): boolean {
+  return err instanceof GrammyError && /can't parse entities|parse entities/i.test(err.description);
+}
+function isNotModified(err: unknown): boolean {
+  return err instanceof GrammyError && /message is not modified/i.test(err.description);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Convert a raw Markdown document to MarkdownV2, split it into Telegram-sized
+ * chunks, and send each — with plain-text fallback per chunk.
+ */
+export async function sendMarkdownDoc(
+  api: Api,
+  chatId: number,
+  rawMarkdown: string,
+  opts?: { loud?: boolean },
+): Promise<void> {
+  const extra = opts?.loud ? { disable_notification: false } : {};
+  const rendered = toTelegramMarkdown(rawMarkdown);
+  const mdChunks = chunkMarkdown(rendered);
+  const plainChunks = chunkMarkdown(rawMarkdown);
+  for (let i = 0; i < mdChunks.length; i++) {
+    await safeSend(api, chatId, mdChunks[i]!, plainChunks[i] ?? mdChunks[i]!, extra);
+  }
+}

package/src/bot/typing.ts

@@ -0,0 +1,35 @@
+/**
+ * Keeps the Telegram "typing…" chat action alive while the agent works.
+ * Telegram clears the action after ~5s, so we re-send every 4s.
+ */
+import type { Api } from "grammy";
+
+export class TypingIndicator {
+  private timer: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly api: Api,
+    private readonly chatId: number,
+  ) {}
+
+  start(): void {
+    if (this.timer) return;
+    void this.ping();
+    this.timer = setInterval(() => void this.ping(), 4000);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  private async ping(): Promise<void> {
+    try {
+      await this.api.sendChatAction(this.chatId, "typing");
+    } catch {
+      /* non-fatal */
+    }
+  }
+}

package/src/bot/wizard/task-wizard.ts

@@ -0,0 +1,214 @@
+/**
+ * Task wizard — a small per-chat state machine that guides task creation and
+ * editing through text and inline steps. Decoupled from Telegram: it returns
+ * WizardPrompt descriptors that the handler renders.
+ */
+import { describeSchedule } from "../../tasks/schedule.js";
+import { parseScheduleDetail } from "../../tasks/schedule.js";
+import type { TaskStore } from "../../tasks/store.js";
+import type { Schedule, ScheduleType } from "../../tasks/types.js";
+
+export type WizStep = "name" | "prompt" | "project" | "scheduleType" | "detail" | "confirm";
+export type WizKind = "text" | "project" | "scheduleType" | "confirm" | "done" | "aborted";
+
+export interface WizardPrompt {
+  kind: WizKind;
+  text: string;
+  error?: boolean;
+}
+
+interface Draft {
+  name?: string;
+  prompt?: string;
+  projectPath?: string;
+  projectName?: string;
+  type?: ScheduleType;
+  schedule?: Schedule;
+}
+
+interface WizardState {
+  mode: "create" | "edit";
+  taskId?: string;
+  steps: WizStep[];
+  index: number;
+  draft: Draft;
+}
+
+const CREATE_STEPS: WizStep[] = ["name", "prompt", "project", "scheduleType", "detail", "confirm"];
+
+export class TaskWizard {
+  private readonly states = new Map<number, WizardState>();
+
+  constructor(private readonly store: TaskStore) {}
+
+  isActive(chatId: number): boolean {
+    return this.states.has(chatId);
+  }
+
+  abort(chatId: number): void {
+    this.states.delete(chatId);
+  }
+
+  startCreate(chatId: number): WizardPrompt {
+    this.states.set(chatId, { mode: "create", steps: CREATE_STEPS, index: 0, draft: {} });
+    return this.promptFor(chatId)!;
+  }
+
+  /** Start an edit flow for a single aspect of an existing task. */
+  startEdit(chatId: number, taskId: string, field: "name" | "prompt" | "project" | "schedule"): WizardPrompt | undefined {
+    const task = this.store.get(taskId);
+    if (!task) return undefined;
+    const steps: Record<string, WizStep[]> = {
+      name: ["name"],
+      prompt: ["prompt"],
+      project: ["project"],
+      schedule: ["scheduleType", "detail"],
+    };
+    this.states.set(chatId, {
+      mode: "edit",
+      taskId,
+      steps: steps[field]!,
+      index: 0,
+      draft: {
+        name: task.name,
+        prompt: task.prompt,
+        projectPath: task.projectPath,
+        projectName: task.projectName,
+        type: task.schedule.type,
+        schedule: task.schedule,
+      },
+    });
+    return this.promptFor(chatId);
+  }
+
+  currentKind(chatId: number): WizKind | undefined {
+    const s = this.states.get(chatId);
+    if (!s) return undefined;
+    return kindOf(s.steps[s.index]!);
+  }
+
+  handleText(chatId: number, text: string): WizardPrompt | undefined {
+    const s = this.states.get(chatId);
+    if (!s) return undefined;
+    const step = s.steps[s.index]!;
+    if (step === "name") s.draft.name = text.trim();
+    else if (step === "prompt") s.draft.prompt = text.trim();
+    else if (step === "detail") {
+      const { schedule, error } = parseScheduleDetail(s.draft.type!, text);
+      if (error) return { kind: "text", text: `\u26A0\uFE0F ${error}`, error: true };
+      s.draft.schedule = schedule;
+    } else {
+      return { kind: kindOf(step), text: "Please use the buttons above to continue.", error: true };
+    }
+    return this.advance(chatId);
+  }
+
+  setProject(chatId: number, path: string, name: string): WizardPrompt | undefined {
+    const s = this.states.get(chatId);
+    if (!s || s.steps[s.index] !== "project") return undefined;
+    s.draft.projectPath = path;
+    s.draft.projectName = name;
+    return this.advance(chatId);
+  }
+
+  setScheduleType(chatId: number, type: ScheduleType): WizardPrompt | undefined {
+    const s = this.states.get(chatId);
+    if (!s || s.steps[s.index] !== "scheduleType") return undefined;
+    s.draft.type = type;
+    s.draft.schedule = { type };
+    return this.advance(chatId);
+  }
+
+  confirm(chatId: number): WizardPrompt | undefined {
+    const s = this.states.get(chatId);
+    if (!s || s.steps[s.index] !== "confirm") return undefined;
+    return this.finalize(chatId);
+  }
+
+  private advance(chatId: number): WizardPrompt {
+    const s = this.states.get(chatId)!;
+    s.index += 1;
+    if (s.index >= s.steps.length) return this.finalize(chatId);
+    return this.promptFor(chatId)!;
+  }
+
+  private finalize(chatId: number): WizardPrompt {
+    const s = this.states.get(chatId)!;
+    const d = s.draft;
+    this.states.delete(chatId);
+    if (s.mode === "create") {
+      const task = this.store.create({
+        chatId,
+        name: d.name ?? "Task",
+        prompt: d.prompt ?? "",
+        projectPath: d.projectPath ?? "",
+        projectName: d.projectName,
+        schedule: d.schedule!,
+      });
+      return { kind: "done", text: `\u2705 Task "${task.name}" created \u2014 ${describeSchedule(task.schedule)}.` };
+    }
+    this.store.update(s.taskId!, {
+      name: d.name,
+      prompt: d.prompt,
+      projectPath: d.projectPath,
+      projectName: d.projectName,
+      schedule: d.schedule,
+    });
+    return { kind: "done", text: "\u2705 Task updated." };
+  }
+
+  private promptFor(chatId: number): WizardPrompt | undefined {
+    const s = this.states.get(chatId);
+    if (!s) return undefined;
+    const step = s.steps[s.index]!;
+    switch (step) {
+      case "name":
+        return { kind: "text", text: "\u{1F4DD} Send a name for the task." };
+      case "prompt":
+        return { kind: "text", text: "\u{1F4AC} Send the prompt Kiro should run when it fires." };
+      case "project":
+        return { kind: "project", text: "\u{1F4C1} Pick the project to run it in:" };
+      case "scheduleType":
+        return { kind: "scheduleType", text: "\u{1F5D3} How often should it run?" };
+      case "detail":
+        return { kind: "text", text: detailQuestion(s.draft.type!) };
+      case "confirm":
+        return { kind: "confirm", text: this.summary(s.draft) };
+    }
+  }
+
+  private summary(d: Draft): string {
+    const p = d.prompt && d.prompt.length > 120 ? d.prompt.slice(0, 120) + "…" : d.prompt;
+    return [
+      "\u{1F4CB} Review the task:",
+      `\u2022 Name: ${d.name}`,
+      `\u2022 Project: ${d.projectName ?? d.projectPath}`,
+      `\u2022 Schedule: ${d.schedule ? describeSchedule(d.schedule) : "?"}`,
+      `\u2022 Prompt: ${p}`,
+      "",
+      "Save this task?",
+    ].join("\n");
+  }
+}
+
+function kindOf(step: WizStep): WizKind {
+  if (step === "project") return "project";
+  if (step === "scheduleType") return "scheduleType";
+  if (step === "confirm") return "confirm";
+  return "text";
+}
+
+function detailQuestion(type: ScheduleType): string {
+  switch (type) {
+    case "once":
+      return "\u{1F5D3} Enter date & time:  YYYY-MM-DD HH:MM";
+    case "daily":
+      return "\u{1F550} Enter time (24h):  HH:MM";
+    case "weekly":
+      return "\u{1F5D3} Enter day & time:  e.g.  Mon 09:00";
+    case "monthly":
+      return "\u{1F5D3} Enter day-of-month & time:  e.g.  15 09:00";
+    case "interval":
+      return "\u23F1 Run every how many minutes?  e.g.  90";
+  }
+}

package/src/cli.ts

@@ -0,0 +1,125 @@
+/**
+ * Command-line interface for the Kiro Telegram Bot.
+ *
+ *   kiro-tg run         Run in the foreground (same as `npm start`)
+ *   kiro-tg install     Install as a background service that starts on boot
+ *   kiro-tg uninstall   Remove the background service
+ *   kiro-tg start|stop|restart|status
+ *   kiro-tg logs [n]    Show the last n log lines (default 100)
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { INSTANCE_DIR, PROJECT_ROOT } from "./config.js";
+import { buildLaunchSpec, getController } from "./service/index.js";
+
+const HELP = `Kiro Telegram Bot — CLI
+
+Usage: kiro-tg <command>
+
+  run                 Run in the foreground
+  setup               Create/update .env in this folder (token + auto-detect)
+  install             Install + start a background service (autostart on boot)
+  uninstall           Stop + remove the background service
+  start               Start the service
+  stop                Stop the service
+  restart             Restart the service
+  status              Show install + running status
+  logs [n]            Show the last n log lines (default 100)
+  help                Show this help
+`;
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const [cmd, arg] = args;
+
+  switch (cmd) {
+    case "run":
+    case undefined:
+      await import("./index.js");
+      return;
+
+    case "setup":
+    case "config": {
+      // Run the plain-node setup script, targeting this folder (.env lives in
+      // the instance dir). Pass through optional <token> [userId] args.
+      const script = join(PROJECT_ROOT, "scripts", "setup.mjs");
+      const r = spawnSync(process.execPath, [script, ...args.slice(1)], {
+        stdio: "inherit",
+        env: { ...process.env, KIRO_TG_CWD: INSTANCE_DIR },
+      });
+      process.exit(r.status ?? 0);
+      break;
+    }
+
+    case "install": {
+      preflight();
+      const r = await getController().install(buildLaunchSpec());
+      console.log(r.ok ? `✓ ${r.message}` : `✗ ${r.message}`);
+      if (r.ok) console.log("\nManage it with: kiro-tg status | stop | restart | logs");
+      process.exit(r.ok ? 0 : 1);
+      break;
+    }
+
+    case "uninstall":
+    case "start":
+    case "stop":
+    case "restart":
+    case "status": {
+      const ctrl = getController();
+      const spec = buildLaunchSpec();
+      let result;
+      if (cmd === "restart") {
+        await ctrl.stop(spec);
+        result = await ctrl.start(spec);
+      } else {
+        result = await ctrl[cmd](spec);
+      }
+      console.log(result.ok ? result.message : `✗ ${result.message}`);
+      process.exit(result.ok ? 0 : 1);
+      break;
+    }
+
+    case "logs":
+      printLogs(arg ? Number(arg) || 100 : 100);
+      break;
+
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      break;
+
+    default:
+      console.error(`Unknown command: ${cmd}\n`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+
+function preflight(): void {
+  const envPath = join(INSTANCE_DIR, ".env");
+  if (!existsSync(envPath)) {
+    console.warn("⚠ No .env found here. Run `kiro-tg setup` and set TELEGRAM_BOT_TOKEN first.");
+    return;
+  }
+  const env = readFileSync(envPath, "utf-8");
+  if (!/^TELEGRAM_BOT_TOKEN=.+/m.test(env)) {
+    console.warn("⚠ TELEGRAM_BOT_TOKEN is not set in .env — the service will fail to start.");
+  }
+}
+
+function printLogs(n: number): void {
+  const file = buildLaunchSpec().logFile;
+  if (!existsSync(file)) {
+    console.log(`No log file yet at ${file}`);
+    return;
+  }
+  const lines = readFileSync(file, "utf-8").split("\n");
+  console.log(lines.slice(-n).join("\n"));
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,190 @@
+/**
+ * Configuration: loads .env, validates required values, resolves paths.
+ */
+import { config as loadDotenv } from "dotenv";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+loadDotenv();
+
+/** Absolute path to the installed bot code (one level above src/). For a global
+ *  npm install this lives inside node_modules — code lives here, never user data. */
+export const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+/**
+ * Directory holding THIS instance's `.env`, `logs/` and `data/`. Resolution:
+ *   1. `--instance <dir>` argv — set by the installed background service,
+ *   2. `KIRO_TG_CWD` env — set by the `kiro-tg` launcher to the user's cwd,
+ *   3. the current working directory.
+ * For a cloned/zip checkout run in place this equals PROJECT_ROOT (so behaviour
+ * is unchanged), while a global `npm i -g` install keeps user data in the
+ * user's folder rather than inside node_modules.
+ */
+export const INSTANCE_DIR = resolveInstanceDir();
+
+function resolveInstanceDir(): string {
+  const flag = process.argv.indexOf("--instance");
+  if (flag !== -1 && process.argv[flag + 1]) return resolve(process.argv[flag + 1]!);
+  const env = process.env.KIRO_TG_CWD?.trim();
+  if (env) return resolve(expandHome(env));
+  return process.cwd();
+}
+
+// Re-load .env from the instance directory (the first call above also primed
+// process.env from cwd, which is the same place for an in-place checkout).
+loadDotenv({ path: join(INSTANCE_DIR, ".env") });
+
+function expandHome(p: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
+  return p;
+}
+
+function bool(v: string | undefined, def: boolean): boolean {
+  if (v === undefined || v === "") return def;
+  return ["1", "true", "yes", "on"].includes(v.toLowerCase());
+}
+
+function num(v: string | undefined, def: number): number {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n : def;
+}
+
+/** Like num() but allows 0 (e.g. to disable retries). Rejects negatives. */
+function nonNegNum(v: string | undefined, def: number): number {
+  if (v === undefined || v === "") return def;
+  const n = Number(v);
+  return Number.isFinite(n) && n >= 0 ? n : def;
+}
+
+function list(v: string | undefined): string[] {
+  return (v || "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export interface AppConfig {
+  token: string;
+  allowedUsers: Set<string>;
+  kiroCliPath: string;
+  workspace: string;
+  agent?: string;
+  trustAllTools: boolean;
+  projectRoots: string[];
+  streamThrottleMs: number;
+  /** Debounce window (ms) for coalescing rapid consecutive text messages
+   *  (e.g. a long message Telegram split at 4096 chars) into one prompt. */
+  messageBatchMs: number;
+  showToolCalls: boolean;
+  showEditDiffs: boolean;
+  diffMaxLines: number;
+  sendAgentImages: boolean;
+  agentImagesMax: number;
+  logLevel: string;
+  sessionsDir: string;
+  projectRoot: string;
+  logsDir: string;
+  logFile: string;
+  acpAutoRestart: boolean;
+  dataDir: string;
+  promptIdleMs: number;
+  quietNotifications: boolean;
+  promptRetryAttempts: number;
+  sttApiUrl?: string;
+  sttApiKey?: string;
+  sttModel: string;
+  sttLanguage?: string;
+  /** Per-server timeout for the /mcp live health probe. */
+  mcpProbeTimeoutMs: number;
+  /** How many MCP health probes run concurrently. */
+  mcpProbeConcurrency: number;
+  /** Show subagent (crew) activity while the main agent waits on them. */
+  showSubagents: boolean;
+}
+
+export function loadConfig(): AppConfig {
+  const token = (process.env.TELEGRAM_BOT_TOKEN || "").trim();
+  if (!token) {
+    throw new Error(
+      "TELEGRAM_BOT_TOKEN is missing. Copy .env.example to .env and set it (run `npm run setup`).",
+    );
+  }
+
+  const workspaceRaw = process.env.KIRO_WORKSPACE?.trim() || process.cwd();
+  const workspace = resolve(expandHome(workspaceRaw));
+
+  // Default project roots: the workspace parent + home directory.
+  const roots = list(process.env.PROJECT_ROOTS).map((p) => resolve(expandHome(p)));
+  if (roots.length === 0) {
+    roots.push(dirname(workspace), homedir());
+  }
+
+  const sessionsDir = join(homedir(), ".kiro", "sessions", "cli");
+  const logsDir = process.env.LOG_DIR?.trim()
+    ? resolve(expandHome(process.env.LOG_DIR.trim()))
+    : join(INSTANCE_DIR, "logs");
+  const logFile = process.env.LOG_FILE?.trim()
+    ? resolve(expandHome(process.env.LOG_FILE.trim()))
+    : join(logsDir, "kiro-telegram-bot.log");
+
+  const cfg: AppConfig = {
+    token,
+    allowedUsers: new Set(list(process.env.ALLOWED_USERS)),
+    kiroCliPath: resolveKiroPath(process.env.KIRO_CLI_PATH?.trim()),
+    workspace,
+    agent: process.env.KIRO_AGENT?.trim() || undefined,
+    trustAllTools: bool(process.env.KIRO_TRUST_ALL_TOOLS, true),
+    projectRoots: [...new Set(roots)],
+    streamThrottleMs: num(process.env.STREAM_THROTTLE_MS, 1500),
+    messageBatchMs: nonNegNum(process.env.MESSAGE_BATCH_MS, 800),
+    showToolCalls: bool(process.env.SHOW_TOOL_CALLS, true),
+    showEditDiffs: bool(process.env.SHOW_EDIT_DIFFS, true),
+    diffMaxLines: num(process.env.DIFF_MAX_LINES, 120),
+    sendAgentImages: bool(process.env.SEND_AGENT_IMAGES, true),
+    agentImagesMax: num(process.env.AGENT_IMAGES_MAX, 8),
+    logLevel: process.env.LOG_LEVEL?.trim() || "info",
+    sessionsDir,
+    projectRoot: PROJECT_ROOT,
+    logsDir,
+    logFile,
+    acpAutoRestart: bool(process.env.ACP_AUTO_RESTART, true),
+    promptIdleMs: num(process.env.PROMPT_IDLE_TIMEOUT_MS, 900_000),
+    quietNotifications: bool(process.env.QUIET_NOTIFICATIONS, true),
+    promptRetryAttempts: nonNegNum(process.env.PROMPT_RETRY_ATTEMPTS, 5),
+    dataDir: process.env.DATA_DIR?.trim()
+      ? resolve(expandHome(process.env.DATA_DIR.trim()))
+      : join(INSTANCE_DIR, "data"),
+    sttApiUrl: process.env.STT_API_URL?.trim() || undefined,
+    sttApiKey: process.env.STT_API_KEY?.trim() || undefined,
+    sttModel: process.env.STT_MODEL?.trim() || "whisper-1",
+    sttLanguage: process.env.STT_LANGUAGE?.trim() || undefined,
+    mcpProbeTimeoutMs: num(process.env.MCP_PROBE_TIMEOUT_MS, 8000),
+    mcpProbeConcurrency: num(process.env.MCP_PROBE_CONCURRENCY, 6),
+    showSubagents: bool(process.env.SHOW_SUBAGENTS, true),
+  };
+
+  return cfg;
+}
+
+/** Resolve the kiro-cli binary path, trying common Windows install dirs. */
+function resolveKiroPath(explicit?: string): string {
+  if (explicit) return expandHome(explicit);
+
+  const candidates = [
+    join(homedir(), "AppData", "Local", "Kiro-Cli", "kiro-cli.exe"),
+    join(homedir(), ".local", "bin", "kiro-cli"),
+    "/usr/local/bin/kiro-cli",
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  // Fall back to PATH lookup.
+  return "kiro-cli";
+}
+
+export function isAbsolutePath(p: string): boolean {
+  return isAbsolute(p);
+}