@aerok/pi-toolkit 0.1.0

package/extensions/bark/index.ts

@@ -0,0 +1,317 @@
+import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import { createBarkClient } from "./client.js";
+import { loadResolvedConfig, validateResolvedConfig } from "./config.js";
+import { fallbackSummary, summarizeForNotification } from "./recap.js";
+import type { BarkEventKey, BarkLevel, CachedModel, NotifyPriority, ResolvedBarkConfig } from "./types.js";
+import { RecapModelSelectorOverlay } from "./tui/model-selector.js";
+import { BarkSettingsOverlay } from "./tui/settings.js";
+import { BarkSetupOverlay } from "./tui/setup.js";
+
+const ASK_USER_PROMPT_EVENT = "rpiv:ask-user:prompt";
+const PERMISSION_PROMPT_EVENT = "permissions:ui_prompt";
+const client = createBarkClient();
+
+function mapPriority(priority: NotifyPriority): BarkLevel {
+  return { low: "passive", normal: "active", high: "timeSensitive" }[priority] as BarkLevel;
+}
+
+function modelRefParts(reference: string): { provider: string; id: string } {
+  const slash = reference.indexOf("/");
+  return slash < 0
+    ? { provider: reference, id: reference }
+    : { provider: reference.slice(0, slash), id: reference.slice(slash + 1) };
+}
+
+function assistantText(message: { role?: string; content?: unknown } | undefined): string | undefined {
+  if (message?.role !== "assistant") return undefined;
+  if (typeof message.content === "string") return message.content;
+  if (!Array.isArray(message.content)) return undefined;
+  const text = message.content
+    .filter((block): block is { type: "text"; text: string } =>
+      typeof block === "object" && block !== null && (block as { type?: string }).type === "text" && typeof (block as { text?: unknown }).text === "string",
+    )
+    .map((block) => block.text)
+    .join("\n");
+  return text || undefined;
+}
+
+function latestAssistantText(ctx: ExtensionContext, payload?: unknown): string | undefined {
+  const messages = (payload as { messages?: Array<{ role?: string; content?: unknown }> } | undefined)?.messages;
+  if (messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+      const text = assistantText(messages[index]);
+      if (text) return text;
+    }
+  }
+  const entries = ctx.sessionManager.getEntries();
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry?.type !== "message") continue;
+    const text = assistantText(entry.message);
+    if (text) return text;
+  }
+  return undefined;
+}
+
+function askUserMessage(payload: unknown): string {
+  const value = payload as { questions?: Array<{ question?: unknown }>; question?: unknown; context?: unknown };
+  const question = value?.questions?.[0]?.question ?? value?.question;
+  return typeof question === "string" && question.trim() ? question.trim() : "Pi is waiting for your answer.";
+}
+
+function permissionMessage(payload: unknown): string {
+  const value = payload as { agentName?: unknown; surface?: unknown; value?: unknown; message?: unknown; forwarded?: unknown };
+  const agent = typeof value?.agentName === "string" && value.agentName.trim() ? value.agentName.trim() : "Agent";
+  const request = [value?.surface, value?.value].filter((item): item is string => typeof item === "string" && item.trim().length > 0).join(" ");
+  const detail = request || (typeof value?.message === "string" ? value.message.trim() : "permission");
+  return `${agent} requested ${detail || "permission"}${value?.forwarded ? " (forwarded)" : ""}.`;
+}
+
+async function recapBody(ctx: ExtensionContext, config: ResolvedBarkConfig, text: string): Promise<string> {
+  const secrets = [config.deviceKey, config.encryption.key, config.encryption.iv];
+  if (!config.recap.enabled) return fallbackSummary(text, secrets);
+  let model: Model<Api> | undefined;
+  if (config.recap.model) {
+    const ref = modelRefParts(config.recap.model);
+    model = ctx.modelRegistry.find(ref.provider, ref.id) as Model<Api> | undefined;
+  } else {
+    model = ctx.model as Model<Api> | undefined;
+  }
+  if (!model) return fallbackSummary(text, secrets);
+
+  try {
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || !auth.apiKey) return fallbackSummary(text, secrets);
+    return summarizeForNotification(
+      text,
+      model,
+      {
+        apiKey: auth.apiKey,
+        headers: auth.headers as ProviderHeaders | undefined,
+      },
+      secrets,
+    );
+  } catch {
+    return fallbackSummary(text, secrets);
+  }
+}
+
+async function send(
+  ctx: ExtensionContext,
+  title: string,
+  body: string,
+  options: { priority?: NotifyPriority; recapText?: string; force?: boolean; sessionName?: string; call?: boolean } = {},
+): Promise<void> {
+  const config = loadResolvedConfig(ctx.cwd);
+  if (!options.force && !config.enabled) throw new Error("Bark notifications are disabled");
+  const errors = validateResolvedConfig(config);
+  if (errors.length > 0) throw new Error(errors.join("; "));
+  const message = options.recapText ? await recapBody(ctx, config, options.recapText) : body;
+  const sessionName = options.sessionName;
+  await client.send(config, {
+    title,
+    body: sessionName ? `${sessionName}: ${message}` : message,
+    level: options.priority ? mapPriority(options.priority) : config.level,
+    group: config.group,
+    sound: config.sound,
+    icon: config.icon,
+    call: options.call,
+  });
+}
+
+function registryModels(ctx: ExtensionContext): CachedModel[] {
+  try {
+    const models = ctx.modelRegistry.getAvailable?.() ?? ctx.modelRegistry.getAll() ?? [];
+    return models.map((model) => ({ provider: model.provider, id: model.id, name: model.name }));
+  } catch {
+    return [];
+  }
+}
+
+function openOverlay(
+  ctx: ExtensionContext,
+  create: (done: () => void, requestRender: () => void, theme: Theme) => {
+    render(width: number): string[];
+    invalidate(): void;
+    handleInput(data: string): void;
+  },
+  width: "60%" | "80%",
+): void {
+  ctx.ui.custom(
+    (tui, theme, _keybindings, done) => create(() => done(undefined), () => tui.requestRender(), theme),
+    { overlay: true, overlayOptions: { width, minWidth: width === "60%" ? 44 : 60, anchor: "center", margin: 2 } },
+  );
+}
+
+export default function barkExtension(pi: ExtensionAPI): void {
+  let sessionCtx: ExtensionContext | undefined;
+  let urgentNextTask = false;
+  let eventUnsubscribers: Array<() => void> = [];
+
+  const notifyEvent = (event: BarkEventKey, title: string, body: string, payload?: unknown): void => {
+    const call = event === "agent_settled" && urgentNextTask;
+    if (event === "agent_settled") {
+      urgentNextTask = false;
+      sessionCtx?.ui.setStatus("pi-toolkit-urgent", undefined);
+    }
+    const ctx = sessionCtx;
+    if (!ctx) return;
+    const config = loadResolvedConfig(ctx.cwd);
+    if (!config.enabled || !config.events[event]) return;
+    const sessionName = pi.getSessionName?.();
+    const notificationTitle = event === "agent_settled" && sessionName ? `Pi · ${sessionName}` : title;
+    const recapText = event === "agent_settled" || event === "agent_end" ? latestAssistantText(ctx, payload) : undefined;
+    void send(ctx, notificationTitle, body, {
+      recapText,
+      sessionName: event === "agent_settled" ? undefined : sessionName,
+      call,
+    }).catch(() => undefined);
+  };
+
+  pi.registerCommand("toolkit:bark-setup", {
+    description: "Configure Bark server and device key",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return void ctx.ui.notify("Bark setup requires an interactive UI.", "warning");
+      openOverlay(ctx, (done, requestRender, theme) => {
+        const overlay = new BarkSetupOverlay();
+        overlay.setTheme(theme);
+        overlay.onClose = done;
+        overlay.requestRender = requestRender;
+        return overlay;
+      }, "80%");
+    },
+  });
+
+  pi.registerCommand("toolkit:bark-encryption-rotate", {
+    description: "Rotate the Bark encryption Key and IV",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return void ctx.ui.notify("Encryption rotation requires an interactive UI.", "warning");
+      openOverlay(ctx, (done, requestRender, theme) => {
+        const overlay = new BarkSetupOverlay(client, "rotate");
+        overlay.setTheme(theme);
+        overlay.onClose = done;
+        overlay.requestRender = requestRender;
+        return overlay;
+      }, "80%");
+    },
+  });
+
+  pi.registerCommand("toolkit:bark-test", {
+    description: "Send a Bark test notification",
+    handler: async (_args, ctx) => {
+      try {
+        await send(ctx, "Pi Toolkit — Test", "Bark notifications are working.", { force: true });
+        ctx.ui.notify("Bark test notification sent.", "info");
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      }
+    },
+  });
+
+  pi.registerCommand("toolkit:bark-urgent", {
+    description: "Toggle continuous ringing for the next completed task",
+    handler: async (_args, ctx) => {
+      urgentNextTask = !urgentNextTask;
+      ctx.ui.setStatus("pi-toolkit-urgent", urgentNextTask ? "☎ next task: 30s ring" : undefined);
+      ctx.ui.notify(
+        urgentNextTask
+          ? "Urgent mode armed: the next completed task will ring for 30 seconds."
+          : "Urgent mode cancelled.",
+        urgentNextTask ? "warning" : "info",
+      );
+    },
+  });
+
+  pi.registerCommand("toolkit:bark-recap-model", {
+    description: "Select the model used for Bark recaps",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return void ctx.ui.notify("Model selection requires an interactive UI.", "warning");
+      const settings = new BarkSettingsOverlay(ctx.cwd);
+      openOverlay(ctx, (done, requestRender, theme) => {
+        const config = loadResolvedConfig(ctx.cwd);
+        const selector = new RecapModelSelectorOverlay(registryModels(ctx), config.recap.model, (model) => {
+          settings.setRecapModel(model);
+          settings.handleInput("\r");
+        });
+        selector.setTheme(theme);
+        selector.onClose = done;
+        selector.requestRender = requestRender;
+        return selector;
+      }, "60%");
+    },
+  });
+
+  pi.registerCommand("toolkit:bark-notify-settings", {
+    description: "Configure Bark events, scopes, and LLM recaps",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return void ctx.ui.notify("Notify settings require an interactive UI.", "warning");
+      openOverlay(ctx, (done, requestRender, theme) => {
+        const overlay = new BarkSettingsOverlay(ctx.cwd);
+        overlay.setTheme(theme);
+        overlay.onClose = done;
+        overlay.requestRender = requestRender;
+        overlay.onOpenModelSelector = (currentModel) => {
+          openOverlay(ctx, (selectorDone, selectorRender, selectorTheme) => {
+            const selector = new RecapModelSelectorOverlay(registryModels(ctx), currentModel, (model) => overlay.setRecapModel(model));
+            selector.setTheme(selectorTheme);
+            selector.onClose = selectorDone;
+            selector.requestRender = selectorRender;
+            return selector;
+          }, "60%");
+        };
+        return overlay;
+      }, "80%");
+    },
+  });
+
+  pi.registerTool({
+    name: "toolkit_notify",
+    label: "Toolkit Notify",
+    description: "Send an explicit Bark notification through the user's pi-toolkit configuration.",
+    parameters: Type.Object({
+      message: Type.String({ description: "Notification body" }),
+      title: Type.Optional(Type.String({ description: "Notification title" })),
+      priority: Type.Optional(Type.String({ enum: ["low", "normal", "high"] })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const values = params as { message: string; title?: string; priority?: NotifyPriority };
+      try {
+        await send(ctx, values.title || "Pi Toolkit", values.message, { priority: values.priority, sessionName: pi.getSessionName?.() });
+        return { content: [{ type: "text" as const, text: "Bark notification sent." }], details: { success: true } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text" as const, text: `Bark notification failed: ${message}` }], details: { success: false, error: message }, isError: true };
+      }
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    sessionCtx = ctx;
+    urgentNextTask = false;
+    ctx.ui.setStatus("pi-toolkit-urgent", undefined);
+    for (const unsubscribe of eventUnsubscribers) unsubscribe();
+    eventUnsubscribers = [
+      pi.events.on(ASK_USER_PROMPT_EVENT, (payload) => notifyEvent("ask_user_prompt", "Pi Toolkit — Question", askUserMessage(payload))),
+      pi.events.on(PERMISSION_PROMPT_EVENT, (payload) => notifyEvent("permission_request", "Pi Toolkit — Permission", permissionMessage(payload))),
+    ];
+  });
+  pi.on("agent_settled", (event) => notifyEvent("agent_settled", "Pi Toolkit — Task Complete", "Agent is complete.", event));
+  pi.on("agent_end", (event) => notifyEvent("agent_end", "Pi Toolkit — Agent Response", "Agent response finished.", event));
+  pi.on("session_shutdown", async () => {
+    const ctx = sessionCtx;
+    if (ctx) {
+      const config = loadResolvedConfig(ctx.cwd);
+      if (config.enabled && config.events.session_shutdown) {
+        await send(ctx, "Pi Toolkit — Session End", "Pi session is closing.", { sessionName: pi.getSessionName?.() }).catch(() => undefined);
+      }
+    }
+    for (const unsubscribe of eventUnsubscribers) unsubscribe();
+    eventUnsubscribers = [];
+    urgentNextTask = false;
+    sessionCtx?.ui.setStatus("pi-toolkit-urgent", undefined);
+    sessionCtx = undefined;
+  });
+}

package/extensions/bark/recap.ts

@@ -0,0 +1,53 @@
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
+import { redactSensitiveText } from "./redact.js";
+
+const SYSTEM_PROMPT =
+  "Summarize the completed work in one concise sentence for a push notification. Never include passwords, keys, tokens, credentials, authorization headers, private keys, or other secrets; replace any such value with [REDACTED]. Reply with only the sanitized summary.";
+const MAX_INPUT_CHARS = 2_000;
+const FALLBACK_CHARS = 120;
+
+export interface RecapCredentials {
+  apiKey: string;
+  headers?: ProviderHeaders;
+}
+
+export function fallbackSummary(text: string, exactSecrets: Array<string | undefined> = []): string {
+  const trimmed = redactSensitiveText(text, exactSecrets).trim();
+  return trimmed.length <= FALLBACK_CHARS ? trimmed : `${trimmed.slice(0, FALLBACK_CHARS)}...`;
+}
+
+/** Summarize through Pi's provider-neutral model adapter. */
+export async function summarizeForNotification(
+  text: string,
+  model: Model<Api>,
+  credentials: RecapCredentials,
+  exactSecrets: Array<string | undefined> = [],
+): Promise<string> {
+  const secrets = [credentials.apiKey, ...exactSecrets];
+  const safeText = redactSensitiveText(text, secrets);
+  const input = safeText.length > MAX_INPUT_CHARS ? `${safeText.slice(0, MAX_INPUT_CHARS)}...` : safeText;
+  try {
+    const response = await completeSimple(
+      model,
+      {
+        systemPrompt: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: input, timestamp: Date.now() }],
+      },
+      {
+        apiKey: credentials.apiKey,
+        headers: credentials.headers,
+        maxTokens: 100,
+        timeoutMs: 10_000,
+      },
+    );
+    const summary = response.content
+      .filter((block): block is Extract<(typeof response.content)[number], { type: "text" }> => block.type === "text")
+      .map((block) => block.text)
+      .join("")
+      .trim();
+    return summary ? redactSensitiveText(summary, secrets) : fallbackSummary(text, secrets);
+  } catch {
+    return fallbackSummary(text, secrets);
+  }
+}

package/extensions/bark/redact.ts

@@ -0,0 +1,21 @@
+const REDACTED = "[REDACTED]";
+
+/** Remove common credentials before text reaches either the recap model or Bark. */
+export function redactSensitiveText(text: string, exactSecrets: Array<string | undefined> = []): string {
+  let safe = text;
+  for (const secret of exactSecrets) {
+    if (secret && secret.length >= 4) safe = safe.split(secret).join(REDACTED);
+  }
+
+  return safe
+    .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gi, REDACTED)
+    .replace(/\b(https?:\/\/)[^/\s:@]+:[^/\s@]+@/gi, `$1${REDACTED}@`)
+    .replace(/\b(https?:\/\/(?:api\.day\.app|[^/\s]+\/push)\/)([^/\s?]+)/gi, `$1${REDACTED}`)
+    .replace(/\b((?:authorization|proxy-authorization)\s*[:=]\s*)(?:bearer|basic)\s+[^\s,;]+/gi, `$1${REDACTED}`)
+    .replace(
+      /((?:\b(?:api[_-]?key|access[_-]?key|secret[_-]?key|private[_-]?key|device[_-]?key|client[_-]?secret|access[_-]?token|auth[_-]?token|refresh[_-]?token|password|passwd|pwd|secret|token|database[_-]?url|dsn)\b|密码|密钥|令牌|口令)\s*["']?\s*(?::|=|：|\bis\b|是)\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|`[^`\r\n]*`|[^\s,;]+)/gi,
+      `$1${REDACTED}`,
+    )
+    .replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|AKIA[0-9A-Z]{16}|xox[a-z]-[A-Za-z0-9-]{16,})\b/g, REDACTED)
+    .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, REDACTED);
+}

package/extensions/bark/tui/model-selector.ts

@@ -0,0 +1,102 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { matchesKey } from "@earendil-works/pi-tui";
+
+import type { CachedModel } from "../types.js";
+import { boxInnerWidth, OverlayTheme } from "./theme.js";
+
+export class RecapModelSelectorOverlay implements Component {
+  private filtered: CachedModel[];
+  private selectedIndex = 0;
+  private filter = "";
+  private filterMode = false;
+  private readonly overlay = new OverlayTheme();
+  onClose?: () => void;
+  requestRender?: () => void;
+
+  constructor(
+    private readonly models: CachedModel[],
+    currentModel: string | undefined,
+    private readonly onSelect: (model: string) => void,
+  ) {
+    this.filtered = [...models];
+    const current = this.filtered.findIndex((model) => `${model.provider}/${model.id}` === currentModel);
+    if (current >= 0) this.selectedIndex = current;
+  }
+
+  setTheme(theme: Theme): void {
+    this.overlay.setTheme(theme);
+  }
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "ctrl+c")) return this.onClose?.();
+    if (this.filterMode) {
+      if (matchesKey(data, "enter")) this.filterMode = false;
+      else if (matchesKey(data, "escape")) {
+        this.filter = "";
+        this.filterMode = false;
+        this.applyFilter();
+      } else if (matchesKey(data, "up")) this.move(-1);
+      else if (matchesKey(data, "down")) this.move(1);
+      else if (matchesKey(data, "backspace") || data === "\x7f" || data === "\b") {
+        this.filter = this.filter.slice(0, -1);
+        this.applyFilter();
+      } else if (data.length === 1 && data >= " ") {
+        this.filter += data;
+        this.applyFilter();
+      }
+      return;
+    }
+    if (matchesKey(data, "escape")) return this.onClose?.();
+    if (matchesKey(data, "up") || data === "k") return this.move(-1);
+    if (matchesKey(data, "down") || data === "j") return this.move(1);
+    if (data === "/") {
+      this.filterMode = true;
+      return;
+    }
+    if (matchesKey(data, "enter")) {
+      const model = this.filtered[this.selectedIndex];
+      if (!model) return;
+      this.onSelect(`${model.provider}/${model.id}`);
+      this.onClose?.();
+    }
+  }
+
+  private move(delta: number): void {
+    this.selectedIndex = Math.max(0, Math.min(Math.max(0, this.filtered.length - 1), this.selectedIndex + delta));
+  }
+
+  private applyFilter(): void {
+    const query = this.filter.toLowerCase();
+    this.filtered = query
+      ? this.models.filter((model) => model.id.toLowerCase().includes(query) || model.name?.toLowerCase().includes(query))
+      : [...this.models];
+    this.selectedIndex = 0;
+  }
+
+  render(width: number): string[] {
+    const inner = boxInnerWidth(width);
+    const lines = [
+      this.overlay.borderLine(inner, "top"),
+      this.overlay.frameLine(this.overlay.fg("accent", this.overlay.bold("🤖 Recap Model")), inner),
+      this.overlay.frameLine(this.overlay.fg("dim", this.filterMode ? `Filter: ${this.filter}█` : `${this.models.length} available models · / filters`), inner),
+      this.overlay.ruleLine(inner),
+    ];
+    const maxRows = Math.max(5, (process.stdout.rows ?? 30) - 12);
+    const start = Math.max(0, this.selectedIndex - Math.floor(maxRows / 2));
+    for (let index = start; index < Math.min(this.filtered.length, start + maxRows); index++) {
+      const model = this.filtered[index];
+      const selected = index === this.selectedIndex;
+      const marker = selected ? this.overlay.fg("accent", "▸") : " ";
+      const label = `${model.name || model.id} ${this.overlay.fg("dim", `[${model.provider}]`)}`;
+      lines.push(this.overlay.frameLine(`  ${marker} ${selected ? this.overlay.bold(label) : label}`, inner));
+    }
+    if (this.filtered.length === 0) lines.push(this.overlay.frameLine(this.overlay.fg("dim", "  No matching models"), inner));
+    lines.push(this.overlay.ruleLine(inner));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", "↑↓ navigate · / filter · Enter select · Esc close"), inner));
+    lines.push(this.overlay.borderLine(inner, "bottom"));
+    return lines;
+  }
+}