@llblab/pi-telegram 0.4.0 → 0.5.1

package/lib/commands.ts

@@ -1,9 +1,10 @@
 /**
  * Telegram command routing helpers
- * Owns slash-command normalization and command side-effect branching behind runtime ports
+ * Owns Telegram slash-command normalization, bot command metadata, and pi-side command registration behind runtime ports
  */
 
 import { pairTelegramUserIfNeeded } from "./config.ts";
+import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
 import {
   createTelegramControlItemBuilder,
   createTelegramControlQueueController,
@@ -31,7 +32,10 @@ export const TELEGRAM_BOT_COMMANDS: readonly TelegramBotCommandDefinition[] = [
   },
   { command: "model", description: "Open the interactive model selector" },
   { command: "compact", description: "Compact the current pi session" },
-  { command: "stop", description: "Abort the current pi task" },
+  {
+    command: "stop",
+    description: "Abort the current pi task and clear queued turns",
+  },
 ];
 
 export interface TelegramBotCommandRegistrationDeps {
@@ -52,22 +56,115 @@ export function createTelegramBotCommandRegistrar(
   return () => registerTelegramBotCommands(deps);
 }
 
+export interface TelegramBridgeCommandStartPollingOptions {
+  force?: boolean;
+}
+
+export interface TelegramBridgeCommandStartPollingResult {
+  ok: boolean;
+  message?: string;
+  canTakeover?: boolean;
+  owner?: string;
+}
+
+export interface TelegramBridgeCommandRegistrationDeps {
+  promptForConfig: (ctx: ExtensionCommandContext) => Promise<void>;
+  getStatusLines: () => string[];
+  reloadConfig: () => Promise<void>;
+  hasBotToken: () => boolean;
+  startPolling: (
+    ctx: ExtensionCommandContext,
+    options?: TelegramBridgeCommandStartPollingOptions,
+  ) =>
+    | void
+    | Promise<void | TelegramBridgeCommandStartPollingResult>
+    | TelegramBridgeCommandStartPollingResult;
+  stopPolling: () => Promise<void | string>;
+  updateStatus: (ctx: ExtensionCommandContext) => void;
+}
+
+function formatTelegramTakeoverTitle(ctx: ExtensionCommandContext): string {
+  return ctx.ui.theme.fg("accent", "pi-telegram");
+}
+
+function formatTelegramTakeoverPrompt(
+  ctx: ExtensionCommandContext,
+  owner?: string,
+): string {
+  const theme = ctx.ui.theme;
+  const action = theme.fg("warning", "move singleton lock here?");
+  const from = theme.fg("muted", "from:");
+  const to = theme.fg("muted", "to:");
+  const source = owner ?? "another pi instance";
+  return `${action}\n\n${from} ${source}\n${to} ${ctx.cwd}`;
+}
+
+export function registerTelegramBridgeCommands(
+  pi: ExtensionAPI,
+  deps: TelegramBridgeCommandRegistrationDeps,
+): void {
+  pi.registerCommand("telegram-setup", {
+    description: "Configure Telegram bot token",
+    handler: async (_args, ctx) => {
+      await deps.promptForConfig(ctx);
+    },
+  });
+  pi.registerCommand("telegram-status", {
+    description: "Show Telegram bridge status",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(deps.getStatusLines().join("\n"), "info");
+    },
+  });
+  pi.registerCommand("telegram-connect", {
+    description: "Start the Telegram bridge in this pi session",
+    handler: async (_args, ctx) => {
+      await deps.reloadConfig();
+      if (!deps.hasBotToken()) {
+        await deps.promptForConfig(ctx);
+        return;
+      }
+      let result = await deps.startPolling(ctx);
+      if (result && !result.ok && result.canTakeover) {
+        const confirmed = await ctx.ui.confirm(
+          formatTelegramTakeoverTitle(ctx),
+          formatTelegramTakeoverPrompt(ctx, result.owner),
+        );
+        if (!confirmed) {
+          ctx.ui.notify("Telegram bridge takeover cancelled.", "info");
+          deps.updateStatus(ctx);
+          return;
+        }
+        result = await deps.startPolling(ctx, { force: true });
+      }
+      if (result?.message) {
+        ctx.ui.notify(result.message, result.ok ? "info" : "warning");
+      }
+      deps.updateStatus(ctx);
+    },
+  });
+  pi.registerCommand("telegram-disconnect", {
+    description: "Stop the Telegram bridge in this pi session",
+    handler: async (_args, ctx) => {
+      const message = await deps.stopPolling();
+      if (message) ctx.ui.notify(message, "info");
+      deps.updateStatus(ctx);
+    },
+  });
+}
+
 export type TelegramCommandAction =
   | { kind: "ignore"; executionMode: "ignored" }
   | { kind: "stop"; executionMode: "immediate" }
   | { kind: "compact"; executionMode: "immediate" }
-  | { kind: "status"; executionMode: "control-queue" }
-  | { kind: "model"; executionMode: "control-queue" }
+  | { kind: "status"; executionMode: "immediate" }
+  | { kind: "model"; executionMode: "immediate" }
   | {
       kind: "help";
       commandName: "help" | "start";
       executionMode: "immediate";
     };
 
-export type TelegramCommandExecutionMode =
-  | "ignored"
-  | "immediate"
-  | "control-queue";
+export type TelegramCommandExecutionMode = "ignored" | "immediate";
 
 export interface TelegramCommandActionDeps<TMessage, TContext> {
   handleStop: (message: TMessage, ctx: TContext) => Promise<void>;
@@ -84,7 +181,7 @@ export interface TelegramCommandActionDeps<TMessage, TContext> {
 export interface TelegramStopCommandDeps {
   hasAbortHandler: () => boolean;
   clearPendingModelSwitch: () => void;
-  hasQueuedTelegramItems: () => boolean;
+  clearQueuedTelegramItems: () => number;
   setPreserveQueuedTurnsAsHistory: (preserve: boolean) => void;
   abortCurrentTurn: () => void;
   updateStatus: () => void;
@@ -99,8 +196,7 @@ export interface TelegramRuntimeEventRecorderPort {
   ) => void;
 }
 
-export interface TelegramCompactCommandDeps
-  extends TelegramRuntimeEventRecorderPort {
+export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorderPort {
   isIdle: () => boolean;
   hasPendingMessages: () => boolean;
   hasActiveTelegramTurn: () => boolean;
@@ -130,14 +226,6 @@ export interface TelegramHelpCommandDeps {
 export type TelegramControlCommandType =
   PendingTelegramControlItem<unknown>["controlType"];
 
-export interface TelegramQueuedControlCommandDeps<TContext> {
-  enqueueControlItem: (
-    controlType: TelegramControlCommandType,
-    statusSummary: string,
-    execute: (ctx: TContext) => Promise<void>,
-  ) => void;
-}
-
 export interface TelegramCommandRuntimeMessage {
   chat: { id: number };
   message_id: number;
@@ -323,6 +411,7 @@ export interface TelegramCommandRuntimeDeps<
   hasAbortHandler: () => boolean;
   clearPendingModelSwitch: () => void;
   hasQueuedTelegramItems: () => boolean;
+  clearQueuedTelegramItems: (ctx: TContext) => number;
   setPreserveQueuedTurnsAsHistory: (preserve: boolean) => void;
   abortCurrentTurn: () => void;
   isIdle: (ctx: TContext) => boolean;
@@ -354,7 +443,7 @@ export interface TelegramCommandRuntimeDeps<
 }
 
 export const TELEGRAM_HELP_TEXT =
-  "Send me a message and I will forward it to pi. Commands: /status, /model, /compact, /stop.";
+  "Send me a message and I will forward it to pi. Commands: /status, /model, /compact, /stop. /stop aborts the current run and clears queued Telegram turns.";
 
 function getTelegramCommandErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
@@ -380,9 +469,9 @@ export function buildTelegramCommandAction(
     case "compact":
       return { kind: "compact", executionMode: "immediate" };
     case "status":
-      return { kind: "status", executionMode: "control-queue" };
+      return { kind: "status", executionMode: "immediate" };
     case "model":
-      return { kind: "model", executionMode: "control-queue" };
+      return { kind: "model", executionMode: "immediate" };
     case "help":
     case "start":
       return { kind: "help", commandName, executionMode: "immediate" };
@@ -397,20 +486,32 @@ export function getTelegramCommandExecutionMode(
   return action.executionMode;
 }
 
+function formatTelegramQueuedTurnCount(count: number): string {
+  return count === 1 ? "1 queued turn" : `${count} queued turns`;
+}
+
 export async function handleTelegramStopCommand(
   deps: TelegramStopCommandDeps,
 ): Promise<void> {
+  deps.clearPendingModelSwitch();
+  const clearedCount = deps.clearQueuedTelegramItems();
+  deps.setPreserveQueuedTurnsAsHistory(false);
   if (!deps.hasAbortHandler()) {
-    await deps.sendTextReply("No active turn.");
+    const clearedSuffix =
+      clearedCount > 0
+        ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
+        : "";
+    if (clearedCount > 0) deps.updateStatus();
+    await deps.sendTextReply(`No active turn.${clearedSuffix}`);
     return;
   }
-  deps.clearPendingModelSwitch();
-  if (deps.hasQueuedTelegramItems()) {
-    deps.setPreserveQueuedTurnsAsHistory(true);
-  }
   deps.abortCurrentTurn();
   deps.updateStatus();
-  await deps.sendTextReply("Aborted current turn.");
+  const clearedSuffix =
+    clearedCount > 0
+      ? ` Cleared ${formatTelegramQueuedTurnCount(clearedCount)}.`
+      : "";
+  await deps.sendTextReply(`Aborted current turn.${clearedSuffix}`);
 }
 
 export async function handleTelegramCompactCommand(
@@ -483,20 +584,18 @@ export async function handleTelegramHelpCommand(
   });
 }
 
-export async function handleTelegramStatusCommand<TContext>(
-  deps: TelegramQueuedControlCommandDeps<TContext> & {
-    showStatus: (ctx: TContext) => Promise<void>;
-  },
-): Promise<void> {
-  deps.enqueueControlItem("status", "⚡ status", deps.showStatus);
+export async function handleTelegramStatusCommand<TContext>(deps: {
+  ctx: TContext;
+  showStatus: (ctx: TContext) => Promise<void>;
+}): Promise<void> {
+  await deps.showStatus(deps.ctx);
 }
 
-export async function handleTelegramModelCommand<TContext>(
-  deps: TelegramQueuedControlCommandDeps<TContext> & {
-    openModelMenu: (ctx: TContext) => Promise<void>;
-  },
-): Promise<void> {
-  deps.enqueueControlItem("model", "⚡ model", deps.openModelMenu);
+export async function handleTelegramModelCommand<TContext>(deps: {
+  ctx: TContext;
+  openModelMenu: (ctx: TContext) => Promise<void>;
+}): Promise<void> {
+  await deps.openModelMenu(deps.ctx);
 }
 
 export async function executeTelegramCommandAction<TMessage, TContext>(
@@ -573,6 +672,7 @@ export function createTelegramCommandHandlerTargetRuntime<
     hasAbortHandler: deps.hasAbortHandler,
     clearPendingModelSwitch: deps.clearPendingModelSwitch,
     hasQueuedTelegramItems: deps.hasQueuedTelegramItems,
+    clearQueuedTelegramItems: deps.clearQueuedTelegramItems,
     setPreserveQueuedTurnsAsHistory: deps.setPreserveQueuedTurnsAsHistory,
     abortCurrentTurn: deps.abortCurrentTurn,
     isIdle: deps.isIdle,
@@ -644,21 +744,6 @@ async function handleTelegramCommandRuntime<
     deps.sendTextReply(nextMessage, text);
   const updateStatusFor = (commandCtx: TContext) => () =>
     deps.updateStatus(commandCtx);
-  const enqueueControlFor =
-    (nextMessage: TMessage, commandCtx: TContext) =>
-    (
-      controlType: TelegramControlCommandType,
-      statusSummary: string,
-      execute: (ctx: TContext) => Promise<void>,
-    ) => {
-      deps.enqueueControlItem(
-        nextMessage,
-        commandCtx,
-        controlType,
-        statusSummary,
-        execute,
-      );
-    };
   return executeTelegramCommandAction(
     buildTelegramCommandAction(commandName),
     message,
@@ -668,7 +753,8 @@ async function handleTelegramCommandRuntime<
         await handleTelegramStopCommand({
           hasAbortHandler: deps.hasAbortHandler,
           clearPendingModelSwitch: deps.clearPendingModelSwitch,
-          hasQueuedTelegramItems: deps.hasQueuedTelegramItems,
+          clearQueuedTelegramItems: () =>
+            deps.clearQueuedTelegramItems(commandCtx),
           setPreserveQueuedTurnsAsHistory: deps.setPreserveQueuedTurnsAsHistory,
           abortCurrentTurn: deps.abortCurrentTurn,
           updateStatus: updateStatusFor(commandCtx),
@@ -694,13 +780,13 @@ async function handleTelegramCommandRuntime<
       },
       handleStatus: async (nextMessage, commandCtx) => {
         await handleTelegramStatusCommand<TContext>({
-          enqueueControlItem: enqueueControlFor(nextMessage, commandCtx),
+          ctx: commandCtx,
           showStatus: (controlCtx) => deps.showStatus(nextMessage, controlCtx),
         });
       },
       handleModel: async (nextMessage, commandCtx) => {
         await handleTelegramModelCommand<TContext>({
-          enqueueControlItem: enqueueControlFor(nextMessage, commandCtx),
+          ctx: commandCtx,
           openModelMenu: (controlCtx) =>
             deps.openModelMenu(nextMessage, controlCtx),
         });