pim-agent 0.0.1 → 0.10.0

package/packages/server/src/probe.ts

@@ -0,0 +1,200 @@
+import { parseArgs } from "node:util";
+
+import type { AttachmentRef } from "#protocol/Command";
+import {
+  isDurableEvent,
+  type ResponseEvent,
+  type ServerEvent,
+} from "#protocol/ServerEvent";
+import { ProbeClient } from "./ProbeClient";
+
+const USAGE = `pim probe — CLI client for pim-server, dumps every frame as JSONL
+
+  bun run probe [options]
+
+  --url <ws://host:port>   server to connect to (default ws://127.0.0.1:4319)
+  --session <uuid>         attach to an existing session (default: create one)
+  --cwd <path>             cwd for a session this probe creates
+  --from-seq <n>           resume from this durable seq (default 0)
+  --prompt <text>          send a user message once attached; sent into a turn
+                           already running it steers that turn
+  --pick-files <query>     ask the server to complete an @ path, print the rows
+  --pick-commands <query>  ask the server for matching skills and commands
+  --list-sessions          print pi's session catalogue and exit
+  --archived               with --list-sessions, print the archived sessions
+                           instead of the live ones
+  --per-project <n>        with --list-sessions, keep at most n sessions per
+                           working directory
+  --archive                put --session out of the live listing
+  --unarchive              bring --session back into it
+  --mark-unread            hold --session unread until something reads it
+  --rename <text>          name --session through pi's own session name;
+                           an empty string clears it
+  --pin <path>             pin a working directory, so its sessions sort first
+  --unpin <path>           unpin it again
+  --list-models            print the models this server can switch to
+  --upload <path>          transfer a local file to the server, attach it to
+                           --prompt (repeatable)
+  --cancel                 cancel the current turn
+  --dequeue                take back what the turn in flight is holding,
+                           without stopping it
+  --wait                   keep streaming after the turn ends (Ctrl-C to stop)
+  --quiet                  print only durable events
+`;
+
+const { values } = parseArgs({
+  options: {
+    url: { type: "string", default: "ws://127.0.0.1:4319" },
+    session: { type: "string" },
+    cwd: { type: "string" },
+    "from-seq": { type: "string", default: "0" },
+    prompt: { type: "string" },
+    "pick-files": { type: "string" },
+    "pick-commands": { type: "string" },
+    "list-sessions": { type: "boolean", default: false },
+    archived: { type: "boolean", default: false },
+    "per-project": { type: "string" },
+    archive: { type: "boolean", default: false },
+    unarchive: { type: "boolean", default: false },
+    "mark-unread": { type: "boolean", default: false },
+    rename: { type: "string" },
+    pin: { type: "string" },
+    unpin: { type: "string" },
+    "list-models": { type: "boolean", default: false },
+    upload: { type: "string", multiple: true },
+    cancel: { type: "boolean", default: false },
+    dequeue: { type: "boolean", default: false },
+    wait: { type: "boolean", default: false },
+    quiet: { type: "boolean", default: false },
+    help: { type: "boolean", default: false },
+  },
+  allowPositionals: false,
+});
+
+if (values.help) {
+  process.stdout.write(USAGE);
+  process.exit(0);
+}
+
+function dump(event: ServerEvent): void {
+  if (values.quiet && !isDurableEvent(event)) {
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+}
+
+const probe = new ProbeClient({
+  url: values.url,
+  ...(values.session === undefined ? {} : { sessionId: values.session }),
+  ...(values.cwd === undefined ? {} : { cwd: values.cwd }),
+  fromSeq: Number(values["from-seq"]),
+  onEvent: dump,
+});
+
+const attached = await probe.connect();
+if (!attached.success) {
+  process.stderr.write(`attach failed: ${attached.error ?? "unknown error"}\n`);
+  process.exit(1);
+}
+
+const mark = probe.events.length;
+if (values["pick-files"] !== undefined) {
+  const started = Bun.nanoseconds();
+  const items = await probe.files.rank(values["pick-files"], { limit: 50 });
+  const ms = (Bun.nanoseconds() - started) / 1e6;
+  process.stderr.write(
+    `pick-files: ${items?.length ?? 0} rows in ${ms.toFixed(1)}ms\n`
+  );
+  for (const item of items ?? []) {
+    process.stdout.write(`${JSON.stringify(item)}\n`);
+  }
+}
+if (values["list-sessions"]) {
+  const started = Bun.nanoseconds();
+  const { sessions, projects } = await probe.catalogue({
+    ...(values.cwd === undefined ? {} : { cwd: values.cwd }),
+    ...(values.archived ? { archived: true } : {}),
+    ...(values["per-project"] === undefined
+      ? {}
+      : { perProject: Number(values["per-project"]) }),
+  });
+  const ms = (Bun.nanoseconds() - started) / 1e6;
+  for (const summary of sessions) {
+    process.stdout.write(`${JSON.stringify(summary)}\n`);
+  }
+  process.stderr.write(
+    `list-sessions: ${sessions.length} rows from ${projects.length} projects in ${ms.toFixed(1)}ms\n`
+  );
+}
+if (values["list-models"]) {
+  process.stdout.write(`${JSON.stringify(await probe.listModels())}\n`);
+}
+if (values["pick-commands"] !== undefined) {
+  const items = await probe.pickCommands(values["pick-commands"]);
+  process.stderr.write(`pick-commands: ${items.length} rows\n`);
+  for (const item of items) {
+    process.stdout.write(`${JSON.stringify(item)}\n`);
+  }
+}
+
+const uploaded: AttachmentRef[] = [];
+for (const path of values.upload ?? []) {
+  const file = await probe.upload(path);
+  uploaded.push({ id: file.id });
+  process.stderr.write(`uploaded: ${JSON.stringify(file)}\n`);
+}
+
+if (values.cancel) {
+  const response = await probe.send({
+    type: "cancel",
+    sessionId: probe.sessionId ?? "",
+  });
+  process.stderr.write(`cancel: ${JSON.stringify(response)}\n`);
+}
+if (values.dequeue) {
+  const response = await probe.send({
+    type: "dequeue",
+    sessionId: probe.sessionId ?? "",
+  });
+  process.stderr.write(`dequeue: ${JSON.stringify(response)}\n`);
+}
+
+const sessionId = probe.sessionId ?? "";
+const report = (what: string, response: ResponseEvent): void => {
+  process.stderr.write(`${what}: ${JSON.stringify(response)}\n`);
+};
+if (values.rename !== undefined) {
+  report("rename", await probe.rename(sessionId, values.rename || null));
+}
+if (values.archive) {
+  report("archive", await probe.setArchived(sessionId, true));
+}
+if (values.unarchive) {
+  report("unarchive", await probe.setArchived(sessionId, false));
+}
+if (values["mark-unread"]) {
+  report("mark-unread", await probe.markUnread(sessionId, true));
+}
+if (values.pin !== undefined) {
+  report("pin", await probe.setPinned(values.pin, true));
+}
+if (values.unpin !== undefined) {
+  report("unpin", await probe.setPinned(values.unpin, false));
+}
+
+if (values.prompt !== undefined) {
+  await probe.promptWith(values.prompt, uploaded);
+}
+
+if (values.prompt !== undefined) {
+  await probe.waitFor(
+    (event) => event.type === "session_state" && event.status === "idle",
+    { timeoutMs: 10 * 60_000, from: mark }
+  );
+}
+
+if (values.wait) {
+  await new Promise<never>(() => {});
+}
+probe.close();
+process.stderr.write(`session ${probe.sessionId} @ seq ${probe.seq}\n`);

package/packages/telegram/src/Bot.ts

@@ -0,0 +1,229 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { Bot as Grammy } from "grammy";
+
+import type { AgentRuntime } from "#core/session/AgentRuntime";
+import { PimVersion } from "#core/shared/PimVersion";
+import { Commands } from "./Commands";
+import type { TelegramConfig } from "./Config";
+import { Message, type Prompt } from "./Message";
+import { Renderer, type TurnEndState } from "./Renderer";
+import { Session, type SessionId } from "./Session";
+import { SessionRegistry } from "./SessionRegistry";
+import type { ScheduledTask } from "./TaskSchema";
+import { TaskScheduler } from "./TaskScheduler";
+import { UpdateConfirm } from "./UpdateConfirm";
+
+export class Bot {
+  private readonly grammy: Grammy;
+  private readonly allowSet: ReadonlySet<number>;
+  private readonly registry: SessionRegistry;
+  private readonly scheduler: TaskScheduler;
+  private readonly config: TelegramConfig;
+  private readonly commands: Commands;
+  /** Grammy's long poll, which only settles once the bot is stopped. */
+  private polling: Promise<void> | undefined;
+
+  public constructor(config: TelegramConfig, runtime: AgentRuntime) {
+    this.config = config;
+    this.grammy = new Grammy(config.token);
+    this.allowSet = new Set(config.allow);
+    this.scheduler = new TaskScheduler({
+      configDir: config.configDir,
+      runTask: (task) => this.runScheduledTask(task),
+    });
+    this.registry = new SessionRegistry(
+      config,
+      this.grammy.api,
+      this.scheduler,
+      runtime
+    );
+    this.commands = new Commands(config, this.grammy.api, this.registry);
+
+    this.grammy.on("callback_query:data", async (ctx) => {
+      if (!this.allowSet.has(ctx.chat?.id ?? -1)) {
+        return;
+      }
+      await this.commands.handleCallback(ctx);
+    });
+
+    this.grammy.on("message", async (ctx) => {
+      const chatId = ctx.chat.id;
+      if (!this.allowSet.has(chatId)) {
+        console.log(`[recv] reject chatId=${chatId} (not in allow-list)`);
+        return;
+      }
+      const sessionId: SessionId = {
+        chatId,
+        threadId: ctx.message.message_thread_id,
+      };
+      let prompt: Prompt | undefined;
+      try {
+        prompt = await Message.toPrompt(
+          ctx,
+          this.config.token,
+          this.config.configDir,
+          sessionId
+        );
+      } catch (err) {
+        await this.reportFailure(sessionId, "attachment download failed", err);
+        return;
+      }
+      if (!prompt) {
+        return;
+      }
+      const preview = prompt.text.slice(0, 120).replace(/\s+/g, " ");
+      console.log(
+        `[recv] chatId=${chatId} threadId=${sessionId.threadId ?? "main"} ${preview}`
+      );
+
+      const session = this.registry.get(sessionId);
+      if (prompt.text.startsWith("/") && !prompt.options.images?.length) {
+        await this.commands.handleCommand(ctx, session, prompt.text);
+        return;
+      }
+
+      void session
+        .run(
+          (agent) => this.handleTurn(session, agent, prompt),
+          session.temporary ? { isolated: true } : undefined
+        )
+        .catch((err: unknown) =>
+          this.reportFailure(sessionId, "turn setup failed", err)
+        );
+    });
+
+    this.grammy.catch((err) => {
+      console.error("[bot] handler error:", err.error);
+    });
+  }
+
+  public async start(): Promise<void> {
+    await this.registry.init();
+    await this.grammy.init();
+    await this.processBootUpdateConfirm();
+    await this.grammy.api.deleteWebhook({ drop_pending_updates: true });
+    const username = this.grammy.botInfo.username;
+    this.registry.setBotUsername(username);
+    console.log(`bot @${username} ready`);
+    await this.scheduler.start();
+    // Polling outlives this call: awaiting it would hold every other surface down with it.
+    this.polling = this.grammy.start().catch((err: unknown) => {
+      console.error("[bot] polling stopped:", err);
+    });
+  }
+
+  public async stop(): Promise<void> {
+    await this.scheduler.stop();
+    await this.grammy.stop();
+    await this.polling;
+    await this.registry.disposeAll();
+  }
+
+  private async runScheduledTask(task: ScheduledTask): Promise<void> {
+    const sessionId: SessionId = {
+      chatId: task.chatId,
+      threadId: task.threadId,
+    };
+    const prompt: Prompt = { text: task.prompt, options: {} };
+    const session = this.registry.get(sessionId);
+    await session
+      .run(
+        (agent) => this.handleTurn(session, agent, prompt),
+        task.isolatedSession ? { isolated: true } : undefined
+      )
+      .catch((err: unknown) =>
+        this.reportFailure(sessionId, `scheduled task ${task.id} failed`, err)
+      );
+  }
+
+  private async reportFailure(
+    sessionId: SessionId,
+    label: string,
+    err: unknown
+  ): Promise<void> {
+    console.error(`[bot] ${label}:`, err);
+    await this.grammy.api
+      .sendMessage(
+        sessionId.chatId,
+        `⚠️ ${(err as Error).message ?? String(err)}`,
+        {
+          message_thread_id: sessionId.threadId,
+          link_preview_options: { is_disabled: true },
+        }
+      )
+      .catch((e: unknown) => console.error(`[send] plain failed:`, e));
+  }
+
+  private async processBootUpdateConfirm(): Promise<void> {
+    const entries = await UpdateConfirm.read(this.config.configDir);
+    if (entries.length === 0) {
+      return;
+    }
+    const [version, piVersion] = await Promise.all([
+      PimVersion.current(),
+      PimVersion.pi(),
+    ]);
+    const text = `✅ Pim Agent updated to v${version} (pi v${piVersion})!`;
+    await Promise.all(
+      entries.map((e) =>
+        this.grammy.api
+          .editMessageText(e.chatId, e.messageId, text, {
+            link_preview_options: { is_disabled: true },
+          })
+          .catch((err) => console.warn(`[update-confirm] edit failed:`, err))
+      )
+    );
+    await UpdateConfirm.clear(this.config.configDir);
+  }
+
+  private async handleTurn(
+    session: Session,
+    agent: AgentSession,
+    prompt: Prompt
+  ): Promise<void> {
+    const renderer = new Renderer(session, this.grammy.api);
+    const unsubscribe = agent.subscribe((event) => renderer.handleEvent(event));
+    await renderer.start();
+    try {
+      await agent.prompt(prompt.text, {
+        ...prompt.options,
+        source: "rpc",
+      });
+      const final = extractFinalResult(agent);
+      await renderer.finish(final.text, final.state);
+    } catch (err) {
+      const msg = (err as Error).message ?? String(err);
+      console.error(`[bot] turn failed:`, err);
+      await renderer.finish(`⚠️ ${msg}`, "error");
+    } finally {
+      unsubscribe();
+    }
+  }
+}
+
+function extractFinalResult(agent: AgentSession): {
+  readonly text: string;
+  readonly state: TurnEndState;
+} {
+  const messages = agent.messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
+    if (msg.role !== "assistant") {
+      continue;
+    }
+    if (msg.stopReason === "error") {
+      return { text: msg.errorMessage ?? "", state: "error" };
+    }
+    if (msg.stopReason === "aborted") {
+      return { text: msg.errorMessage ?? "", state: "cancelled" };
+    }
+    const parts: string[] = [];
+    for (const block of msg.content) {
+      if (block.type === "text") {
+        parts.push(block.text);
+      }
+    }
+    return { text: parts.join("").trim(), state: "ok" };
+  }
+  return { text: "", state: "ok" };
+}