@aerok/pi-toolkit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [0.1.0] - 2026-09-02
+
+Initial public release of pi-toolkit.
+
+### Included
+
+- End-to-end encrypted Bark notifications using AES-128-CBC with PKCS#7 padding.
+- Automatic task-completion notifications with LLM-generated recaps and local fallback summaries.
+- One-shot continuous ringing for important tasks through `/toolkit:bark-urgent`.
+- Interactive Bark setup, encryption rotation, event settings, recap-model selection, and device-side verification.
+- Global private credentials with project-level non-secret preferences.
+- Defense-in-depth redaction before recap, encryption, and Bark transport.
+- Image paste placeholders with vision-model submission, history restoration, and temporary-file cleanup.
+- Local, GitHub, and npm installation support.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neuron Mr White and pi-toolkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,6 @@
+pi-toolkit includes an independently refactored Bark notification extension derived from ideas and MIT-licensed code in Neuron-Mr-White/unipi.
+
+Upstream project: https://github.com/Neuron-Mr-White/unipi
+Bark project and push protocol: https://github.com/finb/bark
+
+The image placeholder extension was migrated from the user's local Pi extension into this package.

package/README.md

@@ -0,0 +1,277 @@
+# pi-toolkit
+
+A focused extension pack for [Pi](https://github.com/earendil-works/pi) that adds encrypted Bark notifications and compact image-paste placeholders.
+
+## Features
+
+### Bark notifications
+
+- End-to-end encrypted delivery by default
+- Automatic notification when a Pi task fully settles
+- One-shot 30-second ringing for important tasks
+- LLM-generated completion recaps with a local fallback
+- Global credentials with project-level, non-secret preferences
+- Official `api.day.app` and self-hosted Bark Server support
+- Manual `toolkit_notify` tool for agent-initiated notifications
+- Defense-in-depth secret redaction
+
+### Image paste placeholders
+
+- Replaces clipboard image paths with readable `[Image N]` markers
+- Sends the original images to vision-capable models
+- Restores image associations from session history
+- Cleans up unused temporary clipboard files
+- Wraps existing custom editors instead of replacing them
+
+pi-toolkit is independent of UniPi. It does not depend on `@pi-unipi/*`, register `/unipi:*` commands, or use `~/.unipi`.
+
+## Requirements
+
+- Node.js 22.19 or later
+- `@earendil-works/pi-coding-agent` 0.84 or later
+
+## Installation
+
+### npm
+
+```bash
+pi install npm:@aerok/pi-toolkit
+```
+
+### GitHub
+
+```bash
+pi install git:github.com/wayne1943x/pi-toolkit
+```
+
+### Local checkout
+
+```bash
+git clone https://github.com/wayne1943x/pi-toolkit.git
+cd pi-toolkit
+npm install
+pi install .
+```
+
+Restart Pi after installation, or run `/reload` in the current session.
+
+## Quick start
+
+1. Run:
+
+   ```text
+   /toolkit:bark-setup
+   ```
+
+2. Paste the test URL shown in the Bark app. The setup wizard extracts the device key.
+3. Configure Bark app encryption with the values generated by the wizard:
+
+   | Bark setting | Value |
+   |---|---|
+   | Algorithm | `AES128` |
+   | Mode | `CBC` |
+   | Padding | `pkcs7` |
+   | Key | Generated 16-character value; press `K` to copy |
+   | IV | Generated 16-character value; press `I` to copy |
+
+4. Send the encrypted test notification.
+5. Confirm activation only if the device displays the readable test sentence. Do not confirm if Bark displays `Decryption Failed`.
+
+The wizard does not save or activate new encryption credentials until this device-side check succeeds.
+
+## Bark commands
+
+| Command | Description |
+|---|---|
+| `/toolkit:bark-setup` | Configure the Bark server, device key, delivery defaults, and encryption |
+| `/toolkit:bark-test` | Send a test using the active encryption mode |
+| `/toolkit:bark-encryption-rotate` | Generate and verify a new encryption Key and IV |
+| `/toolkit:bark-urgent` | Toggle continuous ringing for the next completed task only |
+| `/toolkit:bark-notify-settings` | Configure notification events, encryption mode, and recap behavior |
+| `/toolkit:bark-recap-model` | Select the model used to generate completion recaps |
+
+All Bark commands use the `toolkit:bark-*` namespace so other pi-toolkit extensions can add their own command groups later.
+
+## Default completion notification
+
+When `agent_settled` fires, pi-toolkit sends:
+
+| Field | Default |
+|---|---|
+| Title | `Pi · <session name>`, or `Pi Toolkit — Task Complete` when unnamed |
+| Body | One-sentence LLM recap, with a local fallback |
+| Group | `Pi` |
+| Sound | `anticipate` |
+| Level | `active` |
+| Encryption | Enabled after encrypted setup is completed |
+
+`agent_settled` runs after Pi has finished retries, continuations, and compaction, making it the most reliable standalone task-completion event.
+
+## Important tasks
+
+Before submitting an important task, run:
+
+```text
+/toolkit:bark-urgent
+```
+
+The footer displays:
+
+```text
+☎ next task: 30s ring
+```
+
+The next `agent_settled` notification includes Bark `call=1`, which repeats the selected ringtone for approximately 30 seconds. The state is then cleared, even if delivery fails, so an unrelated later task cannot ring unexpectedly.
+
+Run the command again before task completion to cancel it. Urgent state is session-only and does not register or override Pi's `/fast` command.
+
+## Encrypted delivery
+
+pi-toolkit implements Bark's documented encryption format:
+
+- AES-128
+- CBC mode
+- PKCS#7 padding
+- 16-byte Key
+- 16-byte fixed IV
+- Base64-encoded ciphertext
+
+The title, body, group, sound, icon, level, and call fields are included in the encrypted JSON payload. Delivery fields required by Bark are also sent outside the ciphertext when necessary for routing and processing.
+
+Bark Server and Apple Push Notification service can observe delivery metadata such as the device key, ciphertext, interruption level, and whether continuous ringing was requested. They cannot read the encrypted title or body.
+
+Use the following command to rotate both the Key and IV:
+
+```text
+/toolkit:bark-encryption-rotate
+```
+
+The old configuration remains active until the new encrypted test is readable on the device and explicitly confirmed.
+
+### Plaintext mode
+
+Encrypted delivery can be disabled globally from:
+
+```text
+/toolkit:bark-notify-settings
+```
+
+Disabling encryption requires a second confirmation because Bark Server and Apple Push Notification service will be able to read notification content. Projects cannot override encryption mode or downgrade themselves to plaintext.
+
+## Automatic events
+
+| Event | Default | Description |
+|---|---:|---|
+| `agent_settled` | On | The task is fully complete |
+| `agent_end` | Off | Every low-level agent response; may be noisy |
+| `session_shutdown` | Off | The Pi session is closing |
+| `ask_user_prompt` | Off | An ask-user extension is waiting for input |
+| `permission_request` | Off | A permission extension is waiting for approval |
+
+Configure these events with `/toolkit:bark-notify-settings`.
+
+## LLM recap
+
+Completion notifications use Pi's provider-neutral model adapter to summarize the final assistant response into one sentence.
+
+- Enabled by default
+- Uses the current session model by default
+- A fixed model can be selected with `/toolkit:bark-recap-model`
+- Input is limited to 2,000 characters
+- Output is limited to 100 tokens
+- Requests time out after 10 seconds
+- Model, authentication, network, and empty-output failures fall back to a local sanitized summary
+
+Sensitive values are redacted before text reaches the recap model. Model output is sanitized again before encryption and at the Bark transport boundary.
+
+## Agent notification tool
+
+Agents can send an explicit Bark notification through the same global configuration:
+
+```text
+toolkit_notify({
+  title: "Build Complete",
+  message: "All checks passed.",
+  priority: "normal"
+})
+```
+
+Priority mapping:
+
+| Toolkit priority | Bark level |
+|---|---|
+| `low` | `passive` |
+| `normal` | `active` |
+| `high` | `timeSensitive` |
+
+`high` deliberately does not map to `critical`, avoiding an unexpected bypass of silent or focus modes.
+
+## Configuration
+
+### Global configuration
+
+```text
+~/.pi/agent/pi-toolkit/bark.json
+```
+
+This file contains the Bark server URL, device key, encryption Key and IV, defaults, and global event settings. It is written atomically with file mode `0600`; its parent directory uses mode `0700`.
+
+### Project configuration
+
+```text
+<project>/.pi/pi-toolkit/bark.json
+```
+
+Project configuration may override non-secret preferences such as enabled state, group, sound, icon, level, events, and recap settings. It cannot contain or override the server URL, device key, encryption mode, encryption Key, or IV.
+
+## Image paste placeholders
+
+Paste an image into the Pi TUI using Pi's standard shortcut:
+
+- macOS and Linux: `Ctrl+V`
+- Windows and WSL: `Alt+V`
+
+Instead of showing a long temporary path, the editor displays:
+
+```text
+[Image 1]
+[Image 2]
+```
+
+The marker remains in the prompt so it can be referenced naturally, while the corresponding image is submitted as image content.
+
+Additional behavior:
+
+- Numbering restarts from `[Image 1]` after each successful submission.
+- PNG, JPEG, WebP, and GIF are supported.
+- Session restore and input history reconnect markers to their original images.
+- Removing an unsubmitted marker cleans up its temporary file.
+- Submission is blocked and editor text is restored if the active model does not support image input.
+- Existing custom editor components remain composable.
+
+Do not install a second copy at `~/.pi/agent/extensions/image-placeholders`; duplicate installations would wrap the editor twice.
+
+## Security model
+
+- Notification text is sanitized before recap, before encryption, and at the Bark transport boundary.
+- Redaction covers common passwords, API keys, tokens, authorization headers, private keys, Bark URLs, cloud-token formats, the configured Bark device key, and the configured encryption Key and IV.
+- Matching values are replaced with `[REDACTED]`.
+- Encryption credentials are displayed only in an interactive setup overlay and are not added to the Pi conversation.
+- Copying a Key or IV places a secret on the system clipboard; overwrite it after configuring the Bark app.
+- The Bark device key must still be sent to the configured Bark Server as a routing credential.
+- Redaction is defense in depth, not a guarantee that arbitrary unlabeled secrets can always be recognized. Avoid including credentials in prompts and final responses.
+- Pi extensions execute local code with the user's permissions. Review packages before installation.
+
+## Development
+
+```bash
+npm install
+npm run check
+npm pack --dry-run
+```
+
+The test suite covers configuration migration, encrypted payload compatibility, secret redaction, setup confirmation, one-shot urgent notifications, Bark API behavior, and image placeholder lifecycle handling.
+
+## License
+
+MIT. See [LICENSE](./LICENSE) and [NOTICE](./NOTICE).

package/extensions/bark/client.ts

@@ -0,0 +1,79 @@
+import type { BarkEncryptionConfig, BarkGlobalConfig, BarkNotification } from "./types.js";
+import { encryptPayload } from "./crypto.js";
+import { redactSensitiveText } from "./redact.js";
+
+interface BarkApiResponse {
+  code?: number;
+  message?: string;
+}
+
+type BarkClientConfig = Pick<BarkGlobalConfig, "serverUrl" | "deviceKey"> & {
+  encryption?: BarkEncryptionConfig;
+};
+
+export interface BarkClient {
+  send(config: BarkClientConfig, notification: BarkNotification): Promise<void>;
+}
+
+/**
+ * Create a Bark client. The fetch adapter is injectable so the external HTTP
+ * seam is exercised through the same small interface in production and tests.
+ */
+export function createBarkClient(fetchAdapter: typeof fetch = globalThis.fetch): BarkClient {
+  return {
+    async send(config, notification): Promise<void> {
+      if (!config.deviceKey) throw new Error("Bark device key is required");
+      const baseUrl = config.serverUrl.replace(/\/+$/, "");
+      const endpoint = baseUrl.endsWith("/push") ? baseUrl : `${baseUrl}/push`;
+      const redact = (value: string): string => redactSensitiveText(value, [
+        config.deviceKey,
+        config.encryption?.key,
+        config.encryption?.iv,
+      ]);
+      const payload = {
+        title: redact(notification.title),
+        body: redact(notification.body),
+        ...(notification.group ? { group: redact(notification.group) } : {}),
+        ...(notification.sound ? { sound: notification.sound } : {}),
+        ...(notification.icon ? { icon: redact(notification.icon) } : {}),
+      };
+      const delivery = {
+        ...(notification.level ? { level: notification.level } : {}),
+        ...(notification.call ? { call: "1" } : {}),
+      };
+      const body = config.encryption?.mode === "encrypted"
+        ? {
+            device_key: config.deviceKey,
+            // Bark replaces outer userInfo with this decrypted map before later processors run.
+            ciphertext: encryptPayload({ ...payload, ...delivery }, {
+              key: config.encryption.key ?? "",
+              iv: config.encryption.iv ?? "",
+            }),
+            ...delivery,
+          }
+        : { device_key: config.deviceKey, ...payload, ...delivery };
+
+      const response = await fetchAdapter(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json; charset=utf-8" },
+        body: JSON.stringify(body),
+      });
+      const responseText = await response.text().catch(() => "");
+
+      if (!response.ok) {
+        throw new Error(`Bark API error ${response.status}: ${responseText || "<no body>"}`);
+      }
+      if (!responseText) return;
+
+      try {
+        const result = JSON.parse(responseText) as BarkApiResponse | null;
+        if (result && typeof result.code === "number" && result.code !== 200) {
+          throw new Error(`Bark API error ${result.code}: ${result.message || "unknown error"}`);
+        }
+      } catch (error) {
+        if (error instanceof SyntaxError) return;
+        throw error;
+      }
+    },
+  };
+}

package/extensions/bark/config.ts

@@ -0,0 +1,246 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import type {
+  BarkEventKey,
+  BarkGlobalConfig,
+  BarkLevel,
+  BarkProjectConfig,
+  ResolvedBarkConfig,
+} from "./types.js";
+
+const LEVELS = new Set<BarkLevel>(["critical", "active", "timeSensitive", "passive"]);
+const EVENT_KEYS: BarkEventKey[] = [
+  "agent_settled",
+  "agent_end",
+  "session_shutdown",
+  "ask_user_prompt",
+  "permission_request",
+];
+
+export const DEFAULT_GLOBAL_CONFIG: BarkGlobalConfig = {
+  version: 2,
+  enabled: false,
+  serverUrl: "https://api.day.app",
+  group: "Pi",
+  sound: "anticipate",
+  level: "active",
+  encryption: {
+    mode: "encrypted",
+  },
+  events: {
+    agent_settled: true,
+    agent_end: false,
+    session_shutdown: false,
+    ask_user_prompt: false,
+    permission_request: false,
+  },
+  recap: {
+    enabled: true,
+  },
+};
+
+function cloneDefaults(): BarkGlobalConfig {
+  return {
+    ...DEFAULT_GLOBAL_CONFIG,
+    encryption: { ...DEFAULT_GLOBAL_CONFIG.encryption },
+    events: { ...DEFAULT_GLOBAL_CONFIG.events },
+    recap: { ...DEFAULT_GLOBAL_CONFIG.recap },
+  };
+}
+
+function toolkitConfigRoot(): string {
+  if (process.env.PI_TOOLKIT_CONFIG_DIR) return process.env.PI_TOOLKIT_CONFIG_DIR;
+  const home = process.env.HOME || homedir();
+  return join(home, ".pi", "agent", "pi-toolkit");
+}
+
+export function globalConfigPath(): string {
+  return join(toolkitConfigRoot(), "bark.json");
+}
+
+export function projectConfigPath(cwd: string): string {
+  return join(cwd, ".pi", "pi-toolkit", "bark.json");
+}
+
+function readJson(path: string): unknown {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function optionalNullableString(value: unknown): string | null | undefined {
+  if (value === null) return null;
+  return optionalString(value);
+}
+
+function parseEvents(value: unknown): Partial<Record<BarkEventKey, boolean>> {
+  if (!isRecord(value)) return {};
+  const result: Partial<Record<BarkEventKey, boolean>> = {};
+  for (const key of EVENT_KEYS) {
+    if (typeof value[key] === "boolean") result[key] = value[key];
+  }
+  return result;
+}
+
+function parseGlobal(value: unknown): BarkGlobalConfig {
+  const config = cloneDefaults();
+  if (!isRecord(value)) return config;
+
+  if (typeof value.enabled === "boolean") config.enabled = value.enabled;
+  config.serverUrl = optionalString(value.serverUrl) ?? config.serverUrl;
+  if ("deviceKey" in value) config.deviceKey = optionalString(value.deviceKey);
+  if ("group" in value) config.group = optionalString(value.group);
+  if ("sound" in value) config.sound = optionalString(value.sound);
+  if ("icon" in value) config.icon = optionalString(value.icon);
+  if (typeof value.level === "string" && LEVELS.has(value.level as BarkLevel)) {
+    config.level = value.level as BarkLevel;
+  }
+  if (value.version === 1 && !isRecord(value.encryption)) {
+    // Existing installs stay plaintext until the user completes encrypted setup.
+    config.encryption = { mode: "plaintext" };
+  } else if (isRecord(value.encryption)) {
+    config.encryption = {
+      mode: value.encryption.mode === "plaintext" ? "plaintext" : "encrypted",
+      key: optionalString(value.encryption.key),
+      iv: optionalString(value.encryption.iv),
+    };
+  }
+  config.events = { ...config.events, ...parseEvents(value.events) };
+  if (isRecord(value.recap)) {
+    if (typeof value.recap.enabled === "boolean") config.recap.enabled = value.recap.enabled;
+    if ("model" in value.recap) config.recap.model = optionalString(value.recap.model);
+  }
+  return config;
+}
+
+function parseProject(value: unknown): BarkProjectConfig | undefined {
+  if (!isRecord(value)) return undefined;
+  const config: BarkProjectConfig = { version: 1 };
+  if (typeof value.enabled === "boolean") config.enabled = value.enabled;
+  config.group = optionalNullableString(value.group);
+  config.sound = optionalNullableString(value.sound);
+  config.icon = optionalNullableString(value.icon);
+  if (typeof value.level === "string" && LEVELS.has(value.level as BarkLevel)) {
+    config.level = value.level as BarkLevel;
+  }
+  const events = parseEvents(value.events);
+  if (Object.keys(events).length > 0) config.events = events;
+  if (isRecord(value.recap)) {
+    const recap: BarkProjectConfig["recap"] = {};
+    if (typeof value.recap.enabled === "boolean") recap.enabled = value.recap.enabled;
+    const model = optionalString(value.recap.model);
+    if (model) recap.model = model;
+    if (Object.keys(recap).length > 0) config.recap = recap;
+  }
+  return config;
+}
+
+export function loadGlobalConfig(): BarkGlobalConfig {
+  return parseGlobal(readJson(globalConfigPath()));
+}
+
+export function loadProjectConfig(cwd: string): BarkProjectConfig | undefined {
+  const path = projectConfigPath(cwd);
+  if (!existsSync(path)) return undefined;
+  return parseProject(readJson(path));
+}
+
+function applyNullable(base: string | undefined, override: string | null | undefined): string | undefined {
+  if (override === undefined) return base;
+  return override === null ? undefined : override;
+}
+
+export function loadResolvedConfig(cwd: string): ResolvedBarkConfig {
+  const global = loadGlobalConfig();
+  const project = loadProjectConfig(cwd);
+  if (!project) return { ...global, projectOverride: false };
+
+  return {
+    ...global,
+    enabled: project.enabled ?? global.enabled,
+    group: applyNullable(global.group, project.group),
+    sound: applyNullable(global.sound, project.sound),
+    icon: applyNullable(global.icon, project.icon),
+    level: project.level ?? global.level,
+    events: { ...global.events, ...project.events },
+    recap: { ...global.recap, ...project.recap },
+    projectOverride: true,
+  };
+}
+
+function writePrivateJson(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    renameSync(temp, path);
+  } finally {
+    rmSync(temp, { force: true });
+  }
+}
+
+export function saveGlobalConfig(config: BarkGlobalConfig): void {
+  const normalized = parseGlobal(config);
+  normalized.version = 2;
+  writePrivateJson(globalConfigPath(), normalized);
+}
+
+export function saveProjectConfig(cwd: string, config: BarkProjectConfig): void {
+  const normalized = parseProject(config) ?? { version: 1 as const };
+  normalized.version = 1;
+  writePrivateJson(projectConfigPath(cwd), normalized);
+}
+
+export function isValidEncryptionValue(value: string | undefined): boolean {
+  return typeof value === "string" && Buffer.byteLength(value, "utf8") === 16;
+}
+
+export function validateResolvedConfig(config: ResolvedBarkConfig): string[] {
+  const errors: string[] = [];
+  if (!config.serverUrl) errors.push("Bark server URL is required");
+  if (!config.deviceKey) errors.push("Bark device key is required");
+  try {
+    const url = new URL(config.serverUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      errors.push("Bark server URL must use http or https");
+    }
+  } catch {
+    errors.push("Bark server URL is invalid");
+  }
+  if (config.encryption.mode === "encrypted") {
+    if (!isValidEncryptionValue(config.encryption.key)) errors.push("Bark encryption key must be exactly 16 bytes");
+    if (!isValidEncryptionValue(config.encryption.iv)) errors.push("Bark encryption IV must be exactly 16 bytes");
+  }
+  return errors;
+}
+
+export function normalizeBarkDeviceKey(value: string): string {
+  const trimmed = value.trim();
+  if (!/^https?:\/\//i.test(trimmed)) return trimmed;
+  try {
+    const url = new URL(trimmed);
+    const firstSegment = url.pathname.split("/").filter(Boolean)[0];
+    return firstSegment && firstSegment !== "push" ? firstSegment : trimmed;
+  } catch {
+    return trimmed;
+  }
+}

package/extensions/bark/crypto.ts

@@ -0,0 +1,31 @@
+import { createCipheriv, randomBytes } from "node:crypto";
+
+import { isValidEncryptionValue } from "./config.js";
+
+export interface BarkEncryptionCredentials {
+  key: string;
+  iv: string;
+}
+
+export function generateEncryptionCredentials(): BarkEncryptionCredentials {
+  return {
+    key: randomBytes(12).toString("base64url"),
+    iv: randomBytes(12).toString("base64url"),
+  };
+}
+
+export function encryptText(plaintext: string, credentials: BarkEncryptionCredentials): string {
+  if (!isValidEncryptionValue(credentials.key) || !isValidEncryptionValue(credentials.iv)) {
+    throw new Error("Bark AES-128-CBC key and IV must each be exactly 16 bytes");
+  }
+  const cipher = createCipheriv(
+    "aes-128-cbc",
+    Buffer.from(credentials.key, "utf8"),
+    Buffer.from(credentials.iv, "utf8"),
+  );
+  return Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]).toString("base64");
+}
+
+export function encryptPayload(payload: Record<string, string>, credentials: BarkEncryptionCredentials): string {
+  return encryptText(JSON.stringify(payload), credentials);
+}