pi-control-bridge 0.3.10

package/extension/bridge_client.ts

@@ -0,0 +1,76 @@
+import { getIpcBaseUrl } from "./ensure_bridge.ts";
+import type {
+  BridgeStatus,
+  ControlStatus,
+  PendingCommand,
+  RegisterSessionRequest,
+  RegisterSessionResponse,
+  SessionEventPayload,
+} from "../shared/types.ts";
+import type { TelegramLinkResponse } from "../shared/telegram.ts";
+
+async function ipcRequest<T>(
+  path: string,
+  init?: RequestInit,
+): Promise<T | null> {
+  const response = await fetch(`${getIpcBaseUrl()}${path}`, init);
+  if (response.status === 204) return null;
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`IPC ${path} failed: ${response.status} ${text}`);
+  }
+  return (await response.json()) as T;
+}
+
+export async function registerSession(
+  payload: RegisterSessionRequest,
+): Promise<RegisterSessionResponse> {
+  return ipcRequest<RegisterSessionResponse>("/sessions/register", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  }) as Promise<RegisterSessionResponse>;
+}
+
+export async function unregisterSession(localId: string): Promise<void> {
+  await ipcRequest(`/sessions/${encodeURIComponent(localId)}`, {
+    method: "DELETE",
+  });
+}
+
+export async function requestBridgeShutdownIfIdle(): Promise<void> {
+  await ipcRequest("/shutdown-if-idle", { method: "POST" });
+}
+
+export async function postSessionEvent(
+  localId: string,
+  event: SessionEventPayload,
+): Promise<void> {
+  await ipcRequest(`/sessions/${encodeURIComponent(localId)}/events`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(event),
+  });
+}
+
+export async function waitForCommand(localId: string): Promise<PendingCommand | null> {
+  return ipcRequest<PendingCommand>(
+    `/sessions/${encodeURIComponent(localId)}/commands/wait`,
+  );
+}
+
+export async function getBridgeStatus(): Promise<BridgeStatus & { version?: string }> {
+  return ipcRequest<BridgeStatus & { version?: string }>("/health") as Promise<
+    BridgeStatus & { version?: string }
+  >;
+}
+
+export async function getControlStatus(): Promise<ControlStatus> {
+  return ipcRequest<ControlStatus>("/connection-status") as Promise<ControlStatus>;
+}
+
+export async function createTelegramLinkToken(): Promise<TelegramLinkResponse> {
+  return ipcRequest<TelegramLinkResponse>("/telegram/link-token", {
+    method: "POST",
+  }) as Promise<TelegramLinkResponse>;
+}

package/extension/command_handler.ts

@@ -0,0 +1,39 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { PendingCommand } from "../shared/types.ts";
+
+export function executeCommand(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  command: PendingCommand,
+): void {
+  switch (command.kind) {
+    case "prompt": {
+      const text = String(command.payload?.text ?? "");
+      if (!text) return;
+      if (ctx.isIdle()) {
+        pi.sendUserMessage(text);
+      } else {
+        pi.sendUserMessage(text, { deliverAs: "steer" });
+      }
+      break;
+    }
+    case "interrupt":
+      ctx.abort();
+      break;
+    case "stop":
+      ctx.shutdown();
+      break;
+    case "ping":
+      break;
+    default:
+      console.error(
+        JSON.stringify({
+          level: "WARN",
+          message: "Unknown bridge command kind",
+          kind: command.kind,
+          commandId: command.commandId,
+        }),
+      );
+  }
+}

package/extension/ensure_bridge.ts

@@ -0,0 +1,78 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+
+import { ipcBaseUrl, loadBridgeConfig } from "../shared/config.ts";
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+let configCwd: string | undefined;
+
+/** Pin project cwd for config resolution while a Pi session is active. */
+export function setBridgeConfigCwd(cwd: string | undefined): void {
+  configCwd = cwd;
+}
+
+function configOptions() {
+  return { cwd: configCwd };
+}
+
+export function getBridgeConfig() {
+  return loadBridgeConfig(configOptions());
+}
+
+function resolveBridgeBin(): { bin: string; built: boolean } {
+  const built = join(packageRoot, "dist", "bridge", "main.js");
+  if (existsSync(built)) return { bin: built, built: true };
+  return { bin: join(packageRoot, "bridge", "main.ts"), built: false };
+}
+
+export async function isBridgeRunning(): Promise<boolean> {
+  const config = getBridgeConfig();
+  try {
+    const response = await fetch(`${ipcBaseUrl(config.ipcPort)}/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureBridge(): Promise<boolean> {
+  if (await isBridgeRunning()) return true;
+
+  const config = getBridgeConfig();
+  if (!config.autoStartBridge) return false;
+
+  const { bin, built } = resolveBridgeBin();
+  if (!built) {
+    console.error(
+      JSON.stringify({
+        level: "ERROR",
+        message:
+          "pi-control-bridge: dist/bridge/main.js missing. Reinstall the package (npm:pi-control-bridge).",
+        packageRoot,
+      }),
+    );
+    return false;
+  }
+
+  const child = spawn(process.execPath, [bin, "start"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env,
+  });
+  child.unref();
+
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    if (await isBridgeRunning()) return true;
+  }
+  return false;
+}
+
+export function getIpcBaseUrl(): string {
+  return ipcBaseUrl(getBridgeConfig().ipcPort);
+}

package/extension/hooks.ts

@@ -0,0 +1,291 @@
+import { randomUUID } from "node:crypto";
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import {
+  createTelegramLinkToken,
+  getBridgeStatus,
+  getControlStatus,
+  postSessionEvent,
+  registerSession,
+  requestBridgeShutdownIfIdle,
+  unregisterSession,
+  waitForCommand,
+} from "./bridge_client.ts";
+import { executeCommand } from "./command_handler.ts";
+import { ensureBridge, setBridgeConfigCwd } from "./ensure_bridge.ts";
+import { formatConnectTelegramMessage, formatControlStatusMessage } from "./messages.ts";
+import { buildSessionMetadata } from "./session_metadata.ts";
+import { sessionStatusAfterAgentEnd, sessionStatusFromContext } from "./session_status.ts";
+
+interface SessionBinding {
+  localId: string;
+  consumerAbort: AbortController;
+}
+
+const sessions = new Map<string, SessionBinding>();
+let degradedNotified = false;
+
+function isEphemeral(ctx: ExtensionContext): boolean {
+  return ctx.sessionManager.getSessionFile() === undefined;
+}
+
+async function postEvent(
+  localId: string,
+  eventType: string,
+  status?: string,
+  payload?: Record<string, unknown>,
+): Promise<void> {
+  if (!sessions.has(localId)) return;
+  try {
+    await postSessionEvent(localId, {
+      eventType,
+      status,
+      payload,
+      eventId: randomUUID(),
+    });
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        level: "WARN",
+        message: "Failed to post bridge event",
+        eventType,
+        error: String(error),
+      }),
+    );
+  }
+}
+
+async function postSessionMetadata(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  localId: string,
+  options?: { messages?: unknown[] },
+): Promise<void> {
+  const payload = buildSessionMetadata(pi, ctx, options);
+  if (Object.keys(payload).length === 0) return;
+  await postEvent(localId, "session_metadata", undefined, payload);
+}
+
+function startCommandConsumer(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  localId: string,
+  signal: AbortSignal,
+): void {
+  void (async () => {
+    while (!signal.aborted) {
+      try {
+        const command = await waitForCommand(localId);
+        if (signal.aborted) break;
+        if (command) {
+          executeCommand(pi, ctx, command);
+        }
+      } catch (error) {
+        if (signal.aborted) break;
+        console.error(
+          JSON.stringify({
+            level: "WARN",
+            message: "Command consumer error",
+            error: String(error),
+          }),
+        );
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
+  })();
+}
+
+async function handleSessionStart(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
+  if (isEphemeral(ctx)) return;
+
+  setBridgeConfigCwd(ctx.cwd);
+
+  const ready = await ensureBridge();
+  if (!ready) {
+    if (ctx.hasUI && !degradedNotified) {
+      ctx.ui.notify("Telegram/backend integration unavailable (bridge not running)", "warning");
+      degradedNotified = true;
+    }
+    return;
+  }
+
+  try {
+    const status = await getBridgeStatus();
+    if (status.degraded && ctx.hasUI && !degradedNotified) {
+      ctx.ui.notify("Backend connection degraded; events will be queued locally", "warning");
+      degradedNotified = true;
+    }
+  } catch {
+    if (ctx.hasUI && !degradedNotified) {
+      ctx.ui.notify("Bridge unreachable", "warning");
+      degradedNotified = true;
+    }
+  }
+
+  const localId = ctx.sessionManager.getSessionId();
+  const consumerAbort = new AbortController();
+  const status = sessionStatusFromContext(ctx);
+
+  try {
+    await registerSession({
+      localId,
+      externalSessionId: localId,
+      cwd: ctx.cwd,
+      projectPath: ctx.cwd,
+      title: pi.getSessionName(),
+      pid: process.pid,
+      mode: ctx.mode,
+      status,
+    });
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        level: "ERROR",
+        message: "Session bridge registration failed",
+        error: String(error),
+      }),
+    );
+    return;
+  }
+
+  sessions.set(localId, { localId, consumerAbort });
+  startCommandConsumer(pi, ctx, localId, consumerAbort.signal);
+  await postEvent(localId, "session_start", status);
+  await postSessionMetadata(pi, ctx, localId);
+}
+
+async function handleSessionShutdown(ctx: ExtensionContext): Promise<void> {
+  const localId = ctx.sessionManager.getSessionId();
+  const binding = sessions.get(localId);
+
+  if (binding) {
+    binding.consumerAbort.abort();
+    sessions.delete(localId);
+
+    try {
+      await unregisterSession(localId);
+    } catch (error) {
+      console.error(
+        JSON.stringify({
+          level: "WARN",
+          message: "Session bridge unregister failed",
+          error: String(error),
+        }),
+      );
+    }
+  }
+
+  if (sessions.size > 0) return;
+
+  setBridgeConfigCwd(undefined);
+  try {
+    await requestBridgeShutdownIfIdle();
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        level: "WARN",
+        message: "Bridge idle shutdown request failed",
+        error: String(error),
+      }),
+    );
+  }
+}
+
+export function registerHooks(pi: ExtensionAPI): void {
+  pi.on("session_start", (_event, ctx) =>
+    handleSessionStart(pi, ctx).catch((error) => {
+      console.error(
+        JSON.stringify({
+          level: "ERROR",
+          message: "session_start bridge handler failed",
+          error: String(error),
+        }),
+      );
+    }),
+  );
+
+  pi.on("session_shutdown", (_event, ctx) =>
+    handleSessionShutdown(ctx).catch((error) => {
+      console.error(
+        JSON.stringify({
+          level: "ERROR",
+          message: "session_shutdown bridge handler failed",
+          error: String(error),
+        }),
+      );
+    }),
+  );
+
+  pi.on("agent_start", (_event, ctx) => {
+    void postEvent(ctx.sessionManager.getSessionId(), "agent_start", "running");
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    void postEvent(ctx.sessionManager.getSessionId(), "tool_execution_start", "running", {
+      toolName: event.toolName,
+    });
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    void postEvent(ctx.sessionManager.getSessionId(), "tool_execution_end", "running", {
+      toolName: event.toolName,
+    });
+  });
+
+  pi.on("agent_end", (event, ctx) => {
+    const localId = ctx.sessionManager.getSessionId();
+    const status = sessionStatusAfterAgentEnd(ctx);
+    void postEvent(localId, "agent_end", status);
+    void postSessionMetadata(pi, ctx, localId, { messages: event.messages });
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    const localId = ctx.sessionManager.getSessionId();
+    void postSessionMetadata(pi, ctx, localId, { messages: [event.message] });
+  });
+
+  pi.registerCommand("control-status", {
+    description: "Show pi-control-bridge and Telegram connection status",
+    handler: async (_args, ctx) => {
+      try {
+        const ready = await ensureBridge();
+        if (!ready) {
+          const message = "Bridge is not running. Start a Pi session or run pi-bridge start.";
+          if (ctx.hasUI) ctx.ui.notify(message, "warning");
+          else console.error(message);
+          return;
+        }
+
+        const status = await getControlStatus();
+        const message = formatControlStatusMessage(status);
+        if (ctx.hasUI) ctx.ui.notify(message, "info");
+        else console.error(message);
+      } catch (error) {
+        if (ctx.hasUI) ctx.ui.notify(`Control status error: ${String(error)}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("connect-telegram", {
+    description: "Initialize Telegram control for this device",
+    handler: async (_args, ctx) => {
+      try {
+        const ready = await ensureBridge();
+        if (!ready) {
+          const message = "Bridge is not running. Start a Pi session or run pi-bridge start.";
+          if (ctx.hasUI) ctx.ui.notify(message, "warning");
+          else console.error(message);
+          return;
+        }
+
+        const link = await createTelegramLinkToken();
+        const message = formatConnectTelegramMessage(link);
+        if (ctx.hasUI) ctx.ui.notify(message, "info");
+        else console.error(message);
+      } catch (error) {
+        if (ctx.hasUI) ctx.ui.notify(`Telegram connect error: ${String(error)}`, "error");
+      }
+    },
+  });
+}

package/extension/index.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { registerHooks } from "./hooks.ts";
+
+export default function piControlBridgeExtension(pi: ExtensionAPI): void {
+  registerHooks(pi);
+}

package/extension/messages.ts

@@ -0,0 +1,132 @@
+import { ansi } from "../shared/ansi.ts";
+import { getSystemLocale, pluralMinutes, type AppLocale } from "../shared/locale.ts";
+import type { ControlStatus } from "../shared/types.ts";
+import type { TelegramLinkResponse } from "../shared/telegram.ts";
+
+const connectTelegramCopy = {
+  ru: {
+    title: "Подключение Telegram",
+    alreadyConnectedTitle: "Telegram уже подключён",
+    alreadyConnectedAccount: (username: string) => `Аккаунт: ${username}`,
+    openLink: "Откройте ссылку в Telegram:",
+    openBot: "Откройте бота в Telegram:",
+    sendCommand: (token: string) => `Отправьте команду: /start ${token}`,
+    token: (token: string) => `Токен: ${token}`,
+    sendInBot: "Отправьте в боте: /start <token>",
+    validFor: (minutes: number, until: string) =>
+      `Действует ${minutes} ${pluralMinutes(minutes, "ru")}, до ${until}`,
+  },
+  en: {
+    title: "Connect Telegram",
+    alreadyConnectedTitle: "Telegram already connected",
+    alreadyConnectedAccount: (username: string) => `Account: ${username}`,
+    openLink: "Open this link in Telegram:",
+    openBot: "Open the bot in Telegram:",
+    sendCommand: (token: string) => `Send the command: /start ${token}`,
+    token: (token: string) => `Token: ${token}`,
+    sendInBot: "Send in the bot: /start <token>",
+    validFor: (minutes: number, until: string) =>
+      `Valid for ${minutes} ${pluralMinutes(minutes, "en")}, until ${until}`,
+  },
+} as const;
+
+export interface FormatConnectTelegramOptions {
+  locale?: AppLocale;
+  now?: Date;
+}
+
+export function formatExpiryLine(
+  expiresAt: string,
+  locale: AppLocale,
+  now: Date = new Date(),
+): string | undefined {
+  const expires = new Date(expiresAt);
+  if (Number.isNaN(expires.getTime())) return undefined;
+
+  const diffMs = Math.max(0, expires.getTime() - now.getTime());
+  const minutes = Math.max(1, Math.round(diffMs / 60_000));
+  const until = new Intl.DateTimeFormat(locale === "ru" ? "ru-RU" : "en-GB", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+  }).format(expires);
+
+  return connectTelegramCopy[locale].validFor(minutes, until);
+}
+
+export function formatControlStatusMessage(status: ControlStatus): string {
+  const lines = [
+    "pi-control-bridge",
+    "",
+    `device: ${status.deviceId ?? "n/a"}`,
+    `sessions: ${status.activeSessions}`,
+    `backend: ${status.backendConnected ? "ok" : "degraded"}`,
+    `telegram: ${
+      status.telegram.linked
+        ? `linked${status.telegram.username ? ` (${status.telegram.username})` : ""}`
+        : "not linked"
+    }`,
+  ];
+
+  if (status.bot.username || status.bot.link) {
+    const botLabel = status.bot.username ? `@${status.bot.username.replace(/^@/, "")}` : "bot";
+    lines.push(`bot: ${status.bot.link ? `${botLabel} — ${status.bot.link}` : botLabel}`);
+  }
+
+  lines.push(`pending events: ${status.pendingEvents}`);
+  return lines.join("\n");
+}
+
+export function formatConnectTelegramMessage(
+  link: TelegramLinkResponse,
+  options: FormatConnectTelegramOptions = {},
+): string {
+  const locale = options.locale ?? getSystemLocale();
+  const copy = connectTelegramCopy[locale];
+
+  if (link.alreadyLinked) {
+    const lines = [ansi.title(copy.alreadyConnectedTitle), ""];
+    if (link.telegramUsername) {
+      lines.push(ansi.label(copy.alreadyConnectedAccount(link.telegramUsername)), "");
+    }
+
+    const botUrl =
+      link.botLink ??
+      (link.botUsername ? `https://t.me/${link.botUsername.replace(/^@/, "")}` : undefined);
+    if (botUrl) {
+      lines.push(ansi.label(copy.openBot), ansi.link(botUrl));
+    }
+
+    return lines.join("\n");
+  }
+
+  const lines = [ansi.title(copy.title), ""];
+
+  if (link.botLink) {
+    lines.push(ansi.label(copy.openLink), ansi.link(link.botLink), "");
+  } else if (link.botUsername) {
+    const botUrl = `https://t.me/${link.botUsername.replace(/^@/, "")}`;
+    lines.push(
+      ansi.label(copy.openBot),
+      ansi.link(botUrl),
+      "",
+      ansi.label(copy.sendCommand(link.token)),
+      "",
+    );
+  } else {
+    lines.push(ansi.label(copy.token(link.token)), "", ansi.label(copy.sendInBot), "");
+  }
+
+  if (link.expiresAt) {
+    const expiryLine = formatExpiryLine(link.expiresAt, locale, options.now);
+    if (expiryLine) {
+      lines.push(ansi.accent(expiryLine));
+    }
+  }
+
+  return lines.join("\n");
+}