@aaroncql/pim-agent 0.0.1

package/src/telegram/TaskStore.ts

@@ -0,0 +1,73 @@
+import { readdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+
+import { Fs } from "../shared/Fs";
+import type { ScheduledTask } from "./TaskSchema";
+
+export class TaskStore {
+  public static async loadAll(
+    configDir: string
+  ): Promise<ReadonlyArray<ScheduledTask>> {
+    let entries: string[];
+    try {
+      entries = await readdir(TaskStore.dir(configDir));
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+    const loaded = await Promise.all(
+      entries
+        .filter((name) => name.endsWith(".json"))
+        .map((name) =>
+          Fs.readJsonOrEmpty<ScheduledTask | undefined>(
+            join(TaskStore.dir(configDir), name),
+            undefined
+          )
+        )
+    );
+    return loaded.filter(
+      (data): data is ScheduledTask =>
+        !!data && typeof data === "object" && "id" in data
+    );
+  }
+
+  public static async save(
+    configDir: string,
+    task: ScheduledTask
+  ): Promise<void> {
+    await Fs.writeAtomic(
+      TaskStore.path(configDir, task.id),
+      JSON.stringify(task, null, 2)
+    );
+  }
+
+  public static async delete(configDir: string, id: string): Promise<void> {
+    try {
+      await unlink(TaskStore.path(configDir, id));
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+
+  public static makeId(prompt: string): string {
+    const slug = prompt
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 40);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return slug ? `${slug}-${rand}` : rand;
+  }
+
+  private static dir(configDir: string): string {
+    return join(configDir, "tasks");
+  }
+
+  private static path(configDir: string, id: string): string {
+    return join(TaskStore.dir(configDir), `${id}.json`);
+  }
+}

package/src/telegram/TaskTool.test.ts

@@ -0,0 +1,179 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { SessionId } from "./Session";
+import { TaskScheduler } from "./TaskScheduler";
+import { TaskTool } from "./TaskTool";
+import type { ScheduledTask, TaskToolInput } from "./TaskSchema";
+
+let tmp: string;
+const sessionId: SessionId = { chatId: 7, threadId: undefined };
+const otherSessionId: SessionId = { chatId: 7, threadId: 99 };
+
+beforeEach(async () => {
+  tmp = await mkdtemp(join(tmpdir(), "pim-task-tool-test-"));
+});
+
+afterEach(async () => {
+  await rm(tmp, { recursive: true, force: true });
+});
+
+function makeTool(opts?: { readonly now?: () => number }): {
+  readonly run: (
+    input: TaskToolInput
+  ) => Promise<{ readonly text: string; readonly details: unknown }>;
+  readonly scheduler: TaskScheduler;
+} {
+  const scheduler = new TaskScheduler({
+    configDir: tmp,
+    runTask: async () => {},
+    now: opts?.now ?? ((): number => Date.now()),
+  });
+  const tool = TaskTool.build({ scheduler, sessionId });
+  const run = async (
+    input: TaskToolInput
+  ): Promise<{ readonly text: string; readonly details: unknown }> => {
+    const result = await tool.execute(
+      "test-call-id",
+      input,
+      new AbortController().signal,
+      undefined,
+      // ExtensionContext stub — tool doesn't use it
+      {} as never
+    );
+    return {
+      text: result.content
+        .filter((c): c is { type: "text"; text: string } => c.type === "text")
+        .map((c) => c.text)
+        .join("\n"),
+      details: result.details,
+    };
+  };
+  return { run, scheduler };
+}
+
+describe("task tool: create", () => {
+  test("creates an interval task and returns id + nextRun", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run } = makeTool({ now: () => t0 });
+    const result = await run({
+      action: "create",
+      prompt: "drink water",
+      schedule: { type: "interval", every: "1h" },
+    });
+    expect(result.text).toMatch(/^Created task /);
+    const details = result.details as ScheduledTask;
+    expect(details.prompt).toBe("drink water");
+    expect(details.nextRun).toBe(new Date(t0 + 3600_000).toISOString());
+  });
+
+  test("rejects sub-minute interval", async () => {
+    const { run } = makeTool();
+    await expect(
+      run({
+        action: "create",
+        prompt: "spam",
+        schedule: { type: "interval", every: "10s" },
+      })
+    ).rejects.toThrow(/at least 1 minute/);
+  });
+
+  test("rejects invalid cron", async () => {
+    const { run } = makeTool();
+    await expect(
+      run({
+        action: "create",
+        prompt: "test",
+        schedule: { type: "cron", expr: "not a cron" },
+      })
+    ).rejects.toThrow();
+  });
+
+  test("requires prompt and schedule", async () => {
+    const { run } = makeTool();
+    await expect(run({ action: "create" })).rejects.toThrow(/prompt/);
+    await expect(run({ action: "create", prompt: "hi" })).rejects.toThrow(
+      /schedule/
+    );
+  });
+});
+
+describe("task tool: list/delete/pause/resume", () => {
+  test("list filters to current sessionId", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run, scheduler } = makeTool({ now: () => t0 });
+    await run({
+      action: "create",
+      prompt: "mine",
+      schedule: { type: "interval", every: "1h" },
+    });
+    await scheduler.create(otherSessionId, {
+      prompt: "not mine",
+      schedule: { type: "interval", every: "1h" },
+    });
+    const result = await run({ action: "list" });
+    const details = result.details as { readonly tasks: ScheduledTask[] };
+    expect(details.tasks).toHaveLength(1);
+    expect(details.tasks[0]!.prompt).toBe("mine");
+  });
+
+  test("delete removes by id", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run } = makeTool({ now: () => t0 });
+    const created = await run({
+      action: "create",
+      prompt: "soon-gone",
+      schedule: { type: "interval", every: "1h" },
+    });
+    const id = (created.details as ScheduledTask).id;
+    await run({ action: "delete", id });
+    const list = await run({ action: "list" });
+    expect((list.details as { tasks: ScheduledTask[] }).tasks).toHaveLength(0);
+  });
+
+  test("delete refuses cross-session id", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run, scheduler } = makeTool({ now: () => t0 });
+    const foreign = await scheduler.create(otherSessionId, {
+      prompt: "not yours",
+      schedule: { type: "interval", every: "1h" },
+    });
+    await expect(run({ action: "delete", id: foreign.id })).rejects.toThrow(
+      /no task/
+    );
+  });
+
+  test("pause flips status; resume undoes it", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run } = makeTool({ now: () => t0 });
+    const created = await run({
+      action: "create",
+      prompt: "p",
+      schedule: { type: "interval", every: "1h" },
+    });
+    const id = (created.details as ScheduledTask).id;
+
+    const paused = await run({ action: "pause", id });
+    expect((paused.details as ScheduledTask).status).toBe("paused");
+
+    const resumed = await run({ action: "resume", id });
+    expect((resumed.details as ScheduledTask).status).toBe("active");
+  });
+});
+
+describe("task tool: update_prompt", () => {
+  test("changes prompt text", async () => {
+    const t0 = Date.parse("2026-05-14T12:00:00Z");
+    const { run } = makeTool({ now: () => t0 });
+    const created = await run({
+      action: "create",
+      prompt: "old",
+      schedule: { type: "interval", every: "1h" },
+    });
+    const id = (created.details as ScheduledTask).id;
+    const updated = await run({ action: "update_prompt", id, prompt: "new" });
+    expect((updated.details as ScheduledTask).prompt).toBe("new");
+  });
+});

package/src/telegram/TaskTool.ts

@@ -0,0 +1,159 @@
+import {
+  defineTool,
+  type AgentToolResult,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+
+import type { SessionId } from "./Session";
+import type { TaskScheduler } from "./TaskScheduler";
+import { taskToolSchema, type TaskToolInput } from "./TaskSchema";
+
+export type TaskToolDeps = {
+  readonly scheduler: TaskScheduler;
+  readonly sessionId: SessionId;
+};
+
+export class TaskTool {
+  public static build(deps: TaskToolDeps): ToolDefinition {
+    return defineTool({
+      name: "task",
+      label: "task",
+      description:
+        "Manage scheduled/recurring tasks for this Telegram chat/thread.",
+      parameters: taskToolSchema,
+      async execute(_id, params) {
+        const input = params as TaskToolInput;
+        switch (input.action) {
+          case "create":
+            return await TaskTool.create(deps, input);
+          case "list":
+            return await TaskTool.list(deps);
+          case "delete":
+            return await TaskTool.delete(deps, input);
+          case "pause":
+          case "resume":
+            return await TaskTool.setStatus(deps, input);
+          case "update_prompt":
+            return await TaskTool.updatePrompt(deps, input);
+        }
+      },
+    });
+  }
+
+  private static async create(
+    deps: TaskToolDeps,
+    input: TaskToolInput
+  ): Promise<AgentToolResult<unknown>> {
+    if (!input.prompt) {
+      throw new Error("'prompt' is required for action=create");
+    }
+    if (!input.schedule) {
+      throw new Error("'schedule' is required for action=create");
+    }
+    const task = await deps.scheduler.create(deps.sessionId, {
+      prompt: input.prompt,
+      schedule: input.schedule,
+      expires: input.expires,
+      isolatedSession: input.isolatedSession,
+    });
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Created task ${task.id}. Next run: ${task.nextRun}.`,
+        },
+      ],
+      details: task,
+    };
+  }
+
+  private static async list(
+    deps: TaskToolDeps
+  ): Promise<AgentToolResult<unknown>> {
+    const tasks = await deps.scheduler.list(deps.sessionId);
+    if (tasks.length === 0) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No tasks scheduled for this thread.",
+          },
+        ],
+        details: { tasks: [] },
+      };
+    }
+    return {
+      content: [{ type: "text" as const, text: JSON.stringify(tasks) }],
+      details: { tasks },
+    };
+  }
+
+  private static async delete(
+    deps: TaskToolDeps,
+    input: TaskToolInput
+  ): Promise<AgentToolResult<unknown>> {
+    if (!input.id) {
+      throw new Error("'id' is required for action=delete");
+    }
+    const ok = await deps.scheduler.delete(deps.sessionId, input.id);
+    if (!ok) {
+      throw new Error(`no task with id=${input.id} in this thread`);
+    }
+    return {
+      content: [{ type: "text" as const, text: `Deleted task ${input.id}.` }],
+      details: { id: input.id },
+    };
+  }
+
+  private static async setStatus(
+    deps: TaskToolDeps,
+    input: TaskToolInput
+  ): Promise<AgentToolResult<unknown>> {
+    if (!input.id) {
+      throw new Error(`'id' is required for action=${input.action}`);
+    }
+    const target = input.action === "pause" ? "paused" : "active";
+    const task = await deps.scheduler.setStatus(
+      deps.sessionId,
+      input.id,
+      target
+    );
+    if (!task) {
+      throw new Error(`no task with id=${input.id} in this thread`);
+    }
+    const text =
+      input.action === "pause"
+        ? `Paused task ${task.id}. Will not fire until resumed.`
+        : `Resumed task ${task.id}. Next run: ${task.nextRun}.`;
+    return {
+      content: [{ type: "text" as const, text }],
+      details: task,
+    };
+  }
+
+  private static async updatePrompt(
+    deps: TaskToolDeps,
+    input: TaskToolInput
+  ): Promise<AgentToolResult<unknown>> {
+    if (!input.id) {
+      throw new Error("'id' is required for action=update_prompt");
+    }
+    if (!input.prompt) {
+      throw new Error("'prompt' is required for action=update_prompt");
+    }
+    const task = await deps.scheduler.updatePrompt(
+      deps.sessionId,
+      input.id,
+      input.prompt
+    );
+    if (!task) {
+      throw new Error(`no task with id=${input.id} in this thread`);
+    }
+    return {
+      content: [
+        { type: "text" as const, text: `Updated prompt for task ${task.id}.` },
+      ],
+      details: task,
+    };
+  }
+}

package/src/telegram/TypingIndicator.ts

@@ -0,0 +1,43 @@
+import type { Api } from "grammy";
+
+import type { SessionId } from "./Session";
+
+export class TypingIndicator {
+  private readonly api: Api;
+  private readonly sessionId: SessionId;
+  private timer: Timer | undefined;
+  private stopped = true;
+
+  public constructor(api: Api, sessionId: SessionId) {
+    this.api = api;
+    this.sessionId = sessionId;
+  }
+
+  public start(): void {
+    if (this.timer) {
+      return;
+    }
+    this.stopped = false;
+    void this.send();
+    this.timer = setInterval(() => void this.send(), 4_000);
+  }
+
+  public stop(): void {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  private async send(): Promise<void> {
+    if (this.stopped) {
+      return;
+    }
+    await this.api
+      .sendChatAction(this.sessionId.chatId, "typing", {
+        message_thread_id: this.sessionId.threadId,
+      })
+      .catch(() => {});
+  }
+}

package/src/telegram/index.ts

@@ -0,0 +1,32 @@
+import { Bot } from "./Bot";
+import { Config } from "./Config";
+
+export async function start(args: ReadonlyArray<string>): Promise<void> {
+  const cli = Config.parseArgs(args);
+  const config = await Config.load(cli);
+
+  if (cli.printConfig) {
+    console.log(
+      JSON.stringify(
+        { ...config, token: config.token ? "***" : undefined },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  const bot = new Bot(config);
+  let stopped = false;
+  const stop = (): void => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    void bot.stop();
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+
+  await bot.start();
+}

package/src/themes/pim-dark.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "pim-dark",
+  "vars": {
+    "black": 0,
+    "red": 1,
+    "green": 2,
+    "yellow": 3,
+    "blue": 4,
+    "magenta": 5,
+    "cyan": 6,
+    "white": 7,
+    "gray": 8,
+    "brightRed": 9,
+    "brightGreen": 10,
+    "brightYellow": 11,
+    "brightBlue": 12,
+    "brightMagenta": 13,
+    "brightCyan": 14,
+    "brightWhite": 15,
+
+    "panelBg": "#343541"
+  },
+  "colors": {
+    "accent": "cyan",
+    "border": "gray",
+    "borderAccent": "cyan",
+    "borderMuted": "gray",
+    "success": "green",
+    "error": "red",
+    "warning": "yellow",
+    "muted": "gray",
+    "dim": "gray",
+    "text": "white",
+    "thinkingText": "gray",
+
+    "selectedBg": "panelBg",
+    "userMessageBg": "panelBg",
+    "userMessageText": "",
+    "customMessageBg": "panelBg",
+    "customMessageText": "",
+    "customMessageLabel": "magenta",
+
+    "toolPendingBg": "",
+    "toolSuccessBg": "",
+    "toolErrorBg": "",
+    "toolTitle": "",
+    "toolOutput": "gray",
+
+    "mdHeading": "brightBlue",
+    "mdLink": "",
+    "mdLinkUrl": "brightCyan",
+    "mdCode": "brightMagenta",
+    "mdCodeBlock": "",
+    "mdCodeBlockBorder": "gray",
+    "mdQuote": "brightYellow",
+    "mdQuoteBorder": "brightYellow",
+    "mdHr": "gray",
+    "mdListBullet": "gray",
+
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+
+    "syntaxComment": "gray",
+    "syntaxKeyword": "magenta",
+    "syntaxFunction": "green",
+    "syntaxVariable": "magenta",
+    "syntaxString": "yellow",
+    "syntaxNumber": "blue",
+    "syntaxType": "cyan",
+    "syntaxOperator": "",
+    "syntaxPunctuation": "",
+
+    "thinkingOff": "gray",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "gray",
+    "thinkingMedium": "gray",
+    "thinkingHigh": "gray",
+    "thinkingXhigh": "gray",
+
+    "bashMode": "yellow"
+  }
+}

package/src/themes/pim-light.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "pim-light",
+  "vars": {
+    "black": 0,
+    "red": 1,
+    "green": 2,
+    "yellow": 3,
+    "blue": 4,
+    "magenta": 5,
+    "cyan": 6,
+    "white": 7,
+    "gray": 8,
+    "brightRed": 9,
+    "brightGreen": 10,
+    "brightYellow": 11,
+    "brightBlue": 12,
+    "brightMagenta": 13,
+    "brightCyan": 14,
+    "brightWhite": 15,
+
+    "panelBg": "#e8e8e8"
+  },
+  "colors": {
+    "accent": "blue",
+    "border": "gray",
+    "borderAccent": "blue",
+    "borderMuted": "gray",
+    "success": "green",
+    "error": "red",
+    "warning": "yellow",
+    "muted": "gray",
+    "dim": "gray",
+    "text": "black",
+    "thinkingText": "gray",
+
+    "selectedBg": "panelBg",
+    "userMessageBg": "panelBg",
+    "userMessageText": "",
+    "customMessageBg": "panelBg",
+    "customMessageText": "",
+    "customMessageLabel": "magenta",
+
+    "toolPendingBg": "",
+    "toolSuccessBg": "",
+    "toolErrorBg": "",
+    "toolTitle": "",
+    "toolOutput": "gray",
+
+    "mdHeading": "blue",
+    "mdLink": "",
+    "mdLinkUrl": "cyan",
+    "mdCode": "magenta",
+    "mdCodeBlock": "",
+    "mdCodeBlockBorder": "gray",
+    "mdQuote": "yellow",
+    "mdQuoteBorder": "yellow",
+    "mdHr": "gray",
+    "mdListBullet": "gray",
+
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+
+    "syntaxComment": "gray",
+    "syntaxKeyword": "magenta",
+    "syntaxFunction": "green",
+    "syntaxVariable": "magenta",
+    "syntaxString": "yellow",
+    "syntaxNumber": "blue",
+    "syntaxType": "cyan",
+    "syntaxOperator": "",
+    "syntaxPunctuation": "",
+
+    "thinkingOff": "gray",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "gray",
+    "thinkingMedium": "gray",
+    "thinkingHigh": "gray",
+    "thinkingXhigh": "gray",
+
+    "bashMode": "yellow"
+  }
+}