kiro-telegram-bot 1.5.1

package/src/tasks/runner.ts

@@ -0,0 +1,82 @@
+/**
+ * Executes a scheduled task: opens a fresh session in the task's project,
+ * sends the prompt, collects the response, and delivers it to the chat.
+ * Runs independently of the user's interactive session.
+ */
+import type { Api } from "grammy";
+import { basename } from "node:path";
+import type { AcpClient } from "../acp/client.js";
+import type { SessionUpdate } from "../acp/types.js";
+import { createLogger } from "../logger.js";
+import { sendMarkdownDoc } from "../bot/telegram-io.js";
+import type { Task } from "./types.js";
+
+const log = createLogger("task-runner");
+
+export class TaskRunner {
+  constructor(
+    private readonly api: Api,
+    private readonly acp: AcpClient,
+  ) {}
+
+  /** Run a task; resolves true on success, false on error. */
+  async run(task: Task): Promise<boolean> {
+    log.info(`running task "${task.name}" in ${task.projectPath}`);
+    let sessionId = "";
+    let text = "";
+    let tools = 0;
+    const seen = new Set<string>();
+
+    const listener = (sid: string, u: SessionUpdate): void => {
+      if (sid !== sessionId) return;
+      if (u.sessionUpdate === "agent_message_chunk" && typeof u.content?.text === "string") {
+        text += u.content.text;
+      } else if (u.sessionUpdate === "tool_call") {
+        const id = u.toolCallId || u.title || String(tools);
+        if (!seen.has(id)) {
+          seen.add(id);
+          tools++;
+        }
+      }
+    };
+
+    try {
+      sessionId = await this.acp.newSession(task.projectPath);
+      if (task.agent) {
+        try {
+          await this.acp.setMode(sessionId, task.agent);
+        } catch {
+          /* best-effort */
+        }
+      }
+      this.acp.on("session-update", listener);
+      await this.acp.prompt(sessionId, [{ type: "text", text: task.prompt }]);
+      this.acp.off("session-update", listener);
+      await this.deliver(task, text, tools);
+      return true;
+    } catch (err) {
+      this.acp.off("session-update", listener);
+      await this.deliverError(task, (err as Error).message);
+      log.error(`task "${task.name}" failed:`, (err as Error).message);
+      return false;
+    }
+  }
+
+  private async deliver(task: Task, text: string, tools: number): Promise<void> {
+    const project = task.projectName || basename(task.projectPath);
+    const body = text.trim() || "_(no text output)_";
+    const footer = tools > 0 ? `\n\n\u{1F527} ${tools} tool call(s)` : "";
+    const header = `\u23F0 **Task: ${task.name}** \u00B7 ${project}`;
+    await sendMarkdownDoc(this.api, task.chatId, `${header}\n\n${body}${footer}`, { loud: true });
+  }
+
+  private async deliverError(task: Task, message: string): Promise<void> {
+    try {
+      await this.api.sendMessage(task.chatId, `\u274C Task "${task.name}" failed: ${message}`, {
+        disable_notification: false,
+      });
+    } catch {
+      /* non-fatal */
+    }
+  }
+}

package/src/tasks/schedule.ts

@@ -0,0 +1,142 @@
+/**
+ * Schedule helpers: parse user input, compute the next run time (local
+ * timezone), and produce human-readable descriptions.
+ */
+import type { Schedule, ScheduleType } from "./types.js";
+
+const DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+
+export function parseTime(s: string): { h: number; m: number } | undefined {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(s.trim());
+  if (!m) return undefined;
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (h > 23 || min > 59) return undefined;
+  return { h, m: min };
+}
+
+/** Parse the free-text detail for a given schedule type into a Schedule. */
+export function parseScheduleDetail(
+  type: ScheduleType,
+  text: string,
+): { schedule?: Schedule; error?: string } {
+  const t = text.trim();
+  switch (type) {
+    case "once": {
+      const ms = Date.parse(t.replace(" ", "T"));
+      if (Number.isNaN(ms)) return { error: "Use format: YYYY-MM-DD HH:MM" };
+      if (ms <= Date.now()) return { error: "That time is in the past." };
+      return { schedule: { type, at: new Date(ms).toISOString() } };
+    }
+    case "daily": {
+      const time = parseTime(t);
+      if (!time) return { error: "Use format: HH:MM (e.g. 09:30)" };
+      return { schedule: { type, time: fmt(time) } };
+    }
+    case "weekly": {
+      const [dayStr, timeStr] = t.split(/\s+/);
+      const weekday = DAYS.indexOf((dayStr ?? "").slice(0, 3).toLowerCase());
+      const time = parseTime(timeStr ?? "");
+      if (weekday < 0 || !time) return { error: "Use format: Mon 09:30" };
+      return { schedule: { type, weekday, time: fmt(time) } };
+    }
+    case "monthly": {
+      const [dayStr, timeStr] = t.split(/\s+/);
+      const day = Number(dayStr);
+      const time = parseTime(timeStr ?? "");
+      if (!Number.isInteger(day) || day < 1 || day > 31 || !time) {
+        return { error: "Use format: 15 09:30 (day-of-month time)" };
+      }
+      return { schedule: { type, day, time: fmt(time) } };
+    }
+    case "interval": {
+      const mins = Number(t);
+      if (!Number.isInteger(mins) || mins < 1) return { error: "Enter minutes, e.g. 90" };
+      return { schedule: { type, everyMinutes: mins } };
+    }
+    default:
+      return { error: "Unknown schedule type." };
+  }
+}
+
+/** Next run time in epoch ms, or undefined if the schedule will never fire. */
+export function computeNextRun(schedule: Schedule, from = Date.now()): number | undefined {
+  switch (schedule.type) {
+    case "once": {
+      const ms = schedule.at ? Date.parse(schedule.at) : NaN;
+      return !Number.isNaN(ms) && ms > from ? ms : undefined;
+    }
+    case "interval":
+      return from + (schedule.everyMinutes ?? 60) * 60_000;
+    case "daily":
+      return nextDaily(schedule, from);
+    case "weekly":
+      return nextWeekly(schedule, from);
+    case "monthly":
+      return nextMonthly(schedule, from);
+    default:
+      return undefined;
+  }
+}
+
+function nextDaily(s: Schedule, from: number): number {
+  const { h, m } = splitTime(s.time);
+  const d = new Date(from);
+  d.setHours(h, m, 0, 0);
+  if (d.getTime() <= from) d.setDate(d.getDate() + 1);
+  return d.getTime();
+}
+
+function nextWeekly(s: Schedule, from: number): number {
+  const { h, m } = splitTime(s.time);
+  const target = s.weekday ?? 1;
+  const d = new Date(from);
+  d.setHours(h, m, 0, 0);
+  for (let i = 0; i < 8; i++) {
+    if (d.getDay() === target && d.getTime() > from) return d.getTime();
+    d.setDate(d.getDate() + 1);
+    d.setHours(h, m, 0, 0);
+  }
+  return d.getTime();
+}
+
+function nextMonthly(s: Schedule, from: number): number {
+  const { h, m } = splitTime(s.time);
+  const day = s.day ?? 1;
+  const base = new Date(from);
+  for (let i = 0; i < 13; i++) {
+    const year = base.getFullYear();
+    const month = base.getMonth() + i;
+    const lastDay = new Date(year, month + 1, 0).getDate();
+    const d = new Date(year, month, Math.min(day, lastDay), h, m, 0, 0);
+    if (d.getTime() > from) return d.getTime();
+  }
+  return from + 31 * 86_400_000;
+}
+
+export function describeSchedule(s: Schedule): string {
+  switch (s.type) {
+    case "once":
+      return `once at ${s.at ? new Date(s.at).toLocaleString() : "?"}`;
+    case "daily":
+      return `daily at ${s.time}`;
+    case "weekly":
+      return `weekly on ${DAY_NAMES[s.weekday ?? 1]} at ${s.time}`;
+    case "monthly":
+      return `monthly on day ${s.day} at ${s.time}`;
+    case "interval":
+      return `every ${s.everyMinutes} min`;
+    default:
+      return "unknown";
+  }
+}
+
+function fmt(t: { h: number; m: number }): string {
+  return `${String(t.h).padStart(2, "0")}:${String(t.m).padStart(2, "0")}`;
+}
+
+function splitTime(time?: string): { h: number; m: number } {
+  const p = parseTime(time ?? "09:00");
+  return p ?? { h: 9, m: 0 };
+}

package/src/tasks/scheduler.ts

@@ -0,0 +1,53 @@
+/**
+ * Scheduler — ticks periodically, runs due tasks one at a time, and reschedules
+ * them. One-off tasks are disabled after running.
+ */
+import { createLogger } from "../logger.js";
+import type { TaskRunner } from "./runner.js";
+import { computeNextRun } from "./schedule.js";
+import type { TaskStore } from "./store.js";
+
+const log = createLogger("scheduler");
+const TICK_MS = 30_000;
+
+export class Scheduler {
+  private timer: NodeJS.Timeout | undefined;
+  private running = false;
+
+  constructor(
+    private readonly store: TaskStore,
+    private readonly runner: TaskRunner,
+  ) {}
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(() => void this.tick(), TICK_MS);
+    log.info(`scheduler started (tick ${TICK_MS / 1000}s)`);
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  private async tick(): Promise<void> {
+    if (this.running) return; // never overlap runs
+    const due = this.store.due();
+    if (due.length === 0) return;
+    this.running = true;
+    try {
+      for (const task of due) {
+        const ok = await this.runner.run(task);
+        const isOnce = task.schedule.type === "once";
+        this.store.update(task.id, {
+          lastRun: Date.now(),
+          lastStatus: ok ? "ok" : "error",
+          enabled: isOnce ? false : task.enabled,
+          nextRun: isOnce ? undefined : computeNextRun(task.schedule, Date.now() + 1000),
+        });
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+}

package/src/tasks/store.ts

@@ -0,0 +1,80 @@
+/**
+ * Task persistence and CRUD, backed by a JSON file.
+ */
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { JsonStore } from "../app/json-store.js";
+import { computeNextRun } from "./schedule.js";
+import type { Task } from "./types.js";
+
+export class TaskStore {
+  private readonly store: JsonStore<Task[]>;
+
+  constructor(dataDir: string) {
+    this.store = new JsonStore<Task[]>(join(dataDir, "tasks.json"), []);
+  }
+
+  all(): Task[] {
+    return this.store.get();
+  }
+
+  forChat(chatId: number): Task[] {
+    return this.all()
+      .filter((t) => t.chatId === chatId)
+      .sort((a, b) => (a.nextRun ?? Infinity) - (b.nextRun ?? Infinity));
+  }
+
+  get(id: string): Task | undefined {
+    return this.all().find((t) => t.id === id);
+  }
+
+  create(input: Omit<Task, "id" | "createdAt" | "enabled" | "nextRun">): Task {
+    const task: Task = {
+      ...input,
+      id: randomUUID(),
+      createdAt: Date.now(),
+      enabled: true,
+      nextRun: computeNextRun(input.schedule),
+    };
+    this.store.update((list) => {
+      list.push(task);
+    });
+    return task;
+  }
+
+  update(id: string, patch: Partial<Task>): Task | undefined {
+    let updated: Task | undefined;
+    this.store.update((list) => {
+      const i = list.findIndex((t) => t.id === id);
+      if (i === -1) return;
+      const merged = { ...list[i]!, ...patch };
+      // Recompute nextRun automatically unless the caller set it explicitly.
+      if (!("nextRun" in patch)) {
+        if (!merged.enabled) merged.nextRun = undefined;
+        else if (patch.schedule || patch.enabled !== undefined) {
+          merged.nextRun = computeNextRun(merged.schedule);
+        }
+      }
+      list[i] = merged;
+      updated = merged;
+    });
+    return updated;
+  }
+
+  delete(id: string): boolean {
+    let removed = false;
+    this.store.update((list) => {
+      const i = list.findIndex((t) => t.id === id);
+      if (i !== -1) {
+        list.splice(i, 1);
+        removed = true;
+      }
+    });
+    return removed;
+  }
+
+  /** Tasks that are enabled and due to run at/under `now`. */
+  due(now = Date.now()): Task[] {
+    return this.all().filter((t) => t.enabled && t.nextRun !== undefined && t.nextRun <= now);
+  }
+}

package/src/tasks/types.ts

@@ -0,0 +1,33 @@
+/** Scheduled task model. */
+
+export type ScheduleType = "once" | "daily" | "weekly" | "monthly" | "interval";
+
+export interface Schedule {
+  type: ScheduleType;
+  /** ISO datetime for one-off tasks. */
+  at?: string;
+  /** "HH:MM" 24h local time for daily/weekly/monthly. */
+  time?: string;
+  /** 0=Sunday … 6=Saturday, for weekly. */
+  weekday?: number;
+  /** 1..31, for monthly. */
+  day?: number;
+  /** Minutes between runs, for interval. */
+  everyMinutes?: number;
+}
+
+export interface Task {
+  id: string;
+  chatId: number;
+  name: string;
+  prompt: string;
+  projectPath: string;
+  projectName?: string;
+  agent?: string;
+  schedule: Schedule;
+  enabled: boolean;
+  nextRun?: number; // epoch ms
+  lastRun?: number;
+  lastStatus?: "ok" | "error" | "running";
+  createdAt: number;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2023"],
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": false,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}