@tryinget/pi-activity-strip 0.2.0

package/extensions/activity-strip.js

@@ -0,0 +1,202 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+/** @typedef {import("@earendil-works/pi-coding-agent").ExtensionAPI} ExtensionAPI */
+/** @typedef {import("../src/common/contracts.ts").BeforeAgentStartEventLike} BeforeAgentStartEventLike */
+/** @typedef {import("../src/common/contracts.ts").MessageUpdateEventLike} MessageUpdateEventLike */
+/** @typedef {import("../src/common/contracts.ts").SessionStartContextLike} SessionStartContextLike */
+/** @typedef {import("../src/common/contracts.ts").ToolExecutionEventLike} ToolExecutionEventLike */
+/** @typedef {import("../src/common/contracts.ts").TurnStartEventLike} TurnStartEventLike */
+import { getBrokerStatus, requestBrokerShutdown } from "../src/client/broker-client.mjs";
+import { ensureActivityStripRunning } from "../src/client/launcher.mjs";
+import { createSessionTelemetry } from "../src/client/session-telemetry.mjs";
+import {
+  formatBrokerRuntimeStatus,
+  summarizeBrokerRuntimeStatus,
+} from "../src/common/status-report.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const launcherPath = path.join(packageRoot, "bin", "pi-activity-strip.mjs");
+const execFileAsync = promisify(execFile);
+
+/** @typedef {SessionStartContextLike & { hasUI?: boolean; ui?: { notify?: (message: string, level?: "info" | "warning" | "error") => void; editor?: (title: string, text: string) => Promise<unknown> } }} UiContextLike */
+
+function wantsAutostart() {
+  return process.env.PI_ACTIVITY_STRIP_AUTO_START !== "0";
+}
+
+/** @param {ExtensionAPI} pi */
+export default function activityStripExtension(pi) {
+  const telemetry = createSessionTelemetry({
+    pi,
+    cwd: process.cwd(),
+    sessionName: "",
+  });
+
+  /** @param {UiContextLike} ctx @param {boolean} [announce] */
+  async function ensureOpen(ctx, announce = true) {
+    const result = await ensureActivityStripRunning(launcherPath);
+    if (!ctx?.hasUI || !announce) return result;
+    if (!result.ok) {
+      ctx.ui?.notify?.(result.error ?? "Activity strip did not start", "error");
+      return result;
+    }
+    ctx.ui?.notify?.(
+      result.started ? "Activity strip opened" : "Activity strip already running",
+      "info",
+    );
+    return result;
+  }
+
+  pi.registerCommand("activity-strip", {
+    description: "Open or check the top-row activity strip",
+    /** @param {string} args @param {UiContextLike} ctx */
+    handler: async (args, ctx) => {
+      const action = String(args ?? "")
+        .trim()
+        .toLowerCase();
+      if (action === "status") {
+        try {
+          const result = await getBrokerStatus();
+          if (ctx.hasUI && typeof ctx.ui?.editor === "function") {
+            await ctx.ui.editor("Activity Strip Status", formatBrokerRuntimeStatus(result));
+          } else if (ctx.hasUI) {
+            const summary = summarizeBrokerRuntimeStatus(result);
+            ctx.ui?.notify?.(summary.headline, summary.level);
+          }
+        } catch {
+          if (ctx.hasUI && typeof ctx.ui?.editor === "function") {
+            await ctx.ui.editor("Activity Strip Status", "stopped");
+          } else if (ctx.hasUI) {
+            ctx.ui?.notify?.("Activity strip is stopped", "warning");
+          }
+        }
+        return;
+      }
+
+      if (action === "doctor") {
+        try {
+          const { stdout } = await execFileAsync(process.execPath, [launcherPath, "doctor"], {
+            env: process.env,
+          });
+          if (ctx.hasUI && typeof ctx.ui?.editor === "function") {
+            await ctx.ui.editor("Activity Strip Doctor", stdout.trim() || "No output");
+          } else if (ctx.hasUI) {
+            ctx.ui?.notify?.("Opened activity strip compatibility report", "info");
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Activity strip doctor failed";
+          if (ctx.hasUI && typeof ctx.ui?.editor === "function") {
+            await ctx.ui.editor("Activity Strip Doctor", message);
+          } else if (ctx.hasUI) {
+            ctx.ui?.notify?.(message, "error");
+          }
+        }
+        return;
+      }
+
+      if (action === "fix-top") {
+        try {
+          await execFileAsync(process.execPath, [launcherPath, "fix-top"], {
+            env: process.env,
+          });
+          if (ctx.hasUI) ctx.ui?.notify?.("Moved activity strip to the top edge", "info");
+        } catch (error) {
+          if (ctx.hasUI) {
+            ctx.ui?.notify?.(
+              error instanceof Error ? error.message : "Failed to move activity strip",
+              "error",
+            );
+          }
+        }
+        return;
+      }
+
+      if (action === "stop") {
+        try {
+          const result = await requestBrokerShutdown();
+          if (ctx.hasUI)
+            ctx.ui?.notify?.(
+              result?.ok ? "Stopping activity strip" : "Activity strip is not running",
+              result?.ok ? "info" : "warning",
+            );
+        } catch {
+          if (ctx.hasUI) ctx.ui?.notify?.("Activity strip is not running", "warning");
+        }
+        return;
+      }
+
+      await ensureOpen(ctx, true);
+    },
+  });
+
+  pi.registerCommand("activity-strip-stop", {
+    description: "Stop the running activity strip broker/window",
+    /** @param {string} _args @param {UiContextLike} ctx */
+    handler: async (_args, ctx) => {
+      try {
+        const result = await requestBrokerShutdown();
+        if (ctx.hasUI)
+          ctx.ui?.notify?.(
+            result?.ok ? "Stopping activity strip" : "Activity strip is not running",
+            result?.ok ? "info" : "warning",
+          );
+      } catch {
+        if (ctx.hasUI) ctx.ui?.notify?.("Activity strip is not running", "warning");
+      }
+    },
+  });
+
+  /** @param {unknown} _event @param {UiContextLike} ctx */
+  pi.on("session_start", async (_event, ctx) => {
+    await telemetry.onSessionStart(ctx);
+    if (ctx.hasUI && wantsAutostart()) {
+      await ensureOpen(ctx, false);
+    }
+  });
+
+  /** @param {BeforeAgentStartEventLike} event */
+  pi.on("before_agent_start", async (event) => {
+    telemetry.onBeforeAgentStart(event);
+  });
+
+  /** @param {TurnStartEventLike} event */
+  pi.on("turn_start", async (event) => {
+    telemetry.onTurnStart(event);
+  });
+
+  /** @param {MessageUpdateEventLike} event */
+  pi.on("message_update", async (event) => {
+    telemetry.onMessageUpdate(event);
+  });
+
+  /** @param {ToolExecutionEventLike} event */
+  pi.on("tool_execution_start", async (event) => {
+    telemetry.onToolExecutionStart(event);
+  });
+
+  /** @param {ToolExecutionEventLike} event */
+  pi.on("tool_execution_update", async (event) => {
+    telemetry.onToolExecutionUpdate(event);
+  });
+
+  /** @param {ToolExecutionEventLike} event */
+  pi.on("tool_execution_end", async (event) => {
+    telemetry.onToolExecutionEnd(event);
+  });
+
+  pi.on("turn_end", async () => {
+    telemetry.onTurnEnd();
+  });
+
+  pi.on("agent_settled", async () => {
+    telemetry.onAgentSettled();
+  });
+
+  pi.on("session_shutdown", async () => {
+    await telemetry.shutdown();
+  });
+}

package/extensions/activity-strip.ts

@@ -0,0 +1 @@
+export { default } from "./activity-strip.js";

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@tryinget/pi-activity-strip",
+  "version": "0.2.0",
+  "description": "pi extension package for activity-strip workflows in monorepo runtime",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tryingET/pi-extensions.git",
+    "directory": "packages/pi-activity-strip"
+  },
+  "bugs": {
+    "url": "https://github.com/tryingET/pi-extensions/issues"
+  },
+  "homepage": "https://github.com/tryingET/pi-extensions/tree/main/packages/pi-activity-strip",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "activity-strip",
+    "monorepo"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "fix": "bash ./scripts/quality-gate.sh fix",
+    "lint": "bash ./scripts/quality-gate.sh lint",
+    "typecheck": "bash ./scripts/quality-gate.sh typecheck",
+    "quality:pre-commit": "bash ./scripts/quality-gate.sh pre-commit",
+    "quality:pre-push": "bash ./scripts/quality-gate.sh pre-push",
+    "quality:ci": "bash ./scripts/quality-gate.sh ci",
+    "check": "npm run quality:ci",
+    "test": "npm run quality:ci",
+    "docs:list": "bash ./scripts/docs-list.sh",
+    "docs:list:workspace": "bash ./scripts/docs-list.sh --workspace --discover",
+    "docs:list:json": "bash ./scripts/docs-list.sh --json",
+    "release:check": "bash ./scripts/release-check.sh",
+    "release:check:quick": "SKIP_PI_SMOKE=1 bash ./scripts/release-check.sh",
+    "strip:open": "node ./bin/pi-activity-strip.mjs open",
+    "strip:status": "node ./bin/pi-activity-strip.mjs status",
+    "strip:doctor": "node ./bin/pi-activity-strip.mjs doctor",
+    "strip:snapshot": "node ./bin/pi-activity-strip.mjs snapshot",
+    "strip:fix-top": "node ./bin/pi-activity-strip.mjs fix-top",
+    "strip:stop": "node ./bin/pi-activity-strip.mjs stop",
+    "capture:strip": "bash ./scripts/capture-strip-window.sh",
+    "capture:top": "bash ./scripts/capture-top-band.sh 180",
+    "demo:simulate": "node ./examples/simulate-sessions.mjs",
+    "smoke:headless-live": "bash ./scripts/live-headless-smoke.sh"
+  },
+  "files": [
+    "bin",
+    "extensions/activity-strip.js",
+    "extensions/activity-strip.ts",
+    "src",
+    "prompts",
+    "examples",
+    "policy/security-policy.json"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/activity-strip.js"
+    ],
+    "prompts": [
+      "./prompts"
+    ]
+  },
+  "x-pi-template": {
+    "scaffoldMode": "simple-package",
+    "workspacePath": "packages/pi-activity-strip",
+    "releaseComponent": "pi-activity-strip",
+    "releaseConfigMode": "component"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.4",
+    "@earendil-works/pi-ai": "^0.80.6",
+    "@earendil-works/pi-coding-agent": "^0.80.6",
+    "@types/node": "22.14.0",
+    "@typescript/native-preview": "7.0.0-dev.20260417.1",
+    "typebox": "^1.0.0",
+    "typescript": "5.9.2"
+  },
+  "overrides": {
+    "fast-xml-parser": "5.3.6"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  }
+}

package/policy/security-policy.json

@@ -0,0 +1,10 @@
+{
+  "default": {
+    "maxRiskScore": 70,
+    "requireIntegrity": true,
+    "requireSignatures": false,
+    "allowNpmDiffFallback": false,
+    "minReleaseAgeHours": 0
+  },
+  "packages": {}
+}

package/prompts/pi-activity-strip-implementation-planning.md

@@ -0,0 +1,21 @@
+---
+summary: "Draft an implementation plan for a requested pi-activity-strip change"
+read_when:
+  - "Using or maintaining this package prompt template."
+  - "Checking prompt metadata for pi package discovery or docs-list validation."
+description: Draft an implementation plan for a requested pi-activity-strip change
+system4d:
+  container: "Prompt template for implementation planning."
+  compass: "Turn requests into actionable, risk-aware plans."
+  engine: "Scope -> tasks -> validation -> rollout."
+  fog: "Hidden constraints unless assumptions are surfaced."
+---
+
+Create a pi-activity-strip implementation plan for this request: $@
+
+Include:
+- Scope and non-goals
+- Key risks and mitigations
+- Step-by-step implementation tasks
+- Validation commands and expected outcomes
+- Rollout and rollback notes

package/prompts/pi-activity-strip-security-review.md

@@ -0,0 +1,21 @@
+---
+summary: "Review a pi-activity-strip change for security risks and mitigations"
+read_when:
+  - "Using or maintaining this package prompt template."
+  - "Checking prompt metadata for pi package discovery or docs-list validation."
+description: Review a pi-activity-strip change for security risks and mitigations
+system4d:
+  container: "Prompt template for security-focused review."
+  compass: "Identify practical vulnerabilities before release."
+  engine: "Threats -> impact -> mitigations -> verification."
+  fog: "Partial context can hide exploit paths."
+---
+
+Review this pi-activity-strip change for security concerns: $@
+
+Focus on:
+- Input validation and injection risk
+- Privilege boundaries and secret handling
+- Dependency and supply-chain risk
+- Safe failure modes and logging
+- Concrete remediations with priority

package/src/broker/server.mjs

@@ -0,0 +1,165 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import net from "node:net";
+/** @typedef {import("../common/contracts.ts").ActivityStripBrokerOptions} ActivityStripBrokerOptions */
+import {
+  ACTIVITY_STRIP_BROADCAST_TICK_MS,
+  ACTIVITY_STRIP_SOCKET_DIR,
+  ACTIVITY_STRIP_SOCKET_PATH,
+} from "../common/constants.mjs";
+import { SessionStore } from "./session-store.mjs";
+
+/** @param {string} filePath */
+function safeUnlink(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (error) {
+    if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
+  }
+}
+
+/** @param {unknown} error */
+function isExpectedClientDisconnect(error) {
+  const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+  return code === "ECONNRESET" || code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+
+/** @param {string} line */
+function parseLine(line) {
+  const trimmed = String(line ?? "").trim();
+  if (!trimmed) return null;
+  return JSON.parse(trimmed);
+}
+
+export class ActivityStripBroker extends EventEmitter {
+  /** @param {ActivityStripBrokerOptions} [options] */
+  constructor(options = {}) {
+    super();
+    this.socketPath = options.socketPath ?? ACTIVITY_STRIP_SOCKET_PATH;
+    this.socketDir = options.socketDir ?? ACTIVITY_STRIP_SOCKET_DIR;
+    this.store = options.store ?? new SessionStore();
+    this.getRuntimeStatus = options.getRuntimeStatus ?? (() => undefined);
+    this.server = net.createServer((socket) => this.handleConnection(socket));
+    this.tick = null;
+  }
+
+  async start() {
+    fs.mkdirSync(this.socketDir, { recursive: true });
+    safeUnlink(this.socketPath);
+
+    await new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.socketPath, () => {
+        this.server.off("error", reject);
+        resolve(undefined);
+      });
+    });
+
+    this.tick = setInterval(() => {
+      this.emitSnapshot();
+    }, ACTIVITY_STRIP_BROADCAST_TICK_MS);
+    this.tick.unref?.();
+    this.emitSnapshot();
+  }
+
+  emitSnapshot() {
+    this.emit("snapshot", this.store.snapshot());
+  }
+
+  /** @param {import("node:net").Socket} socket @param {Record<string, unknown>} message */
+  reply(socket, message) {
+    if (socket.destroyed || !socket.writable) return;
+    try {
+      socket.write(`${JSON.stringify(message)}\n`, (error) => {
+        if (error && !isExpectedClientDisconnect(error)) this.emit("client-error", error);
+      });
+    } catch (error) {
+      if (!isExpectedClientDisconnect(error)) this.emit("client-error", error);
+    }
+  }
+
+  /** @param {import("node:net").Socket} socket */
+  handleConnection(socket) {
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("error", (error) => {
+      if (!isExpectedClientDisconnect(error)) this.emit("client-error", error);
+    });
+
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex >= 0) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        this.handleMessage(socket, line);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    });
+  }
+
+  /** @param {import("node:net").Socket} socket @param {string} line */
+  handleMessage(socket, line) {
+    let message;
+    try {
+      message = parseLine(line);
+    } catch (error) {
+      this.reply(socket, {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return;
+    }
+
+    if (!message) return;
+
+    switch (message.type) {
+      case "ping":
+        this.reply(socket, {
+          ok: true,
+          type: "pong",
+          snapshot: this.store.snapshot(),
+          runtimeStatus: this.getRuntimeStatus(),
+        });
+        return;
+      case "shutdown":
+        this.reply(socket, { ok: true, type: "shutdown" });
+        setTimeout(() => {
+          this.emit("shutdown-requested");
+        }, 20);
+        return;
+      case "remove":
+        this.store.remove(message.sessionId);
+        this.emitSnapshot();
+        return;
+      case "upsert":
+        this.store.upsert(message.session);
+        this.emitSnapshot();
+        return;
+      default:
+        this.reply(socket, { ok: false, error: `Unsupported message type: ${message.type}` });
+    }
+  }
+
+  async stop() {
+    if (this.tick) {
+      clearInterval(this.tick);
+      this.tick = null;
+    }
+
+    await new Promise((resolve) => {
+      this.server.close(() => resolve(undefined));
+    });
+
+    safeUnlink(this.socketPath);
+  }
+}
+
+/** @param {ActivityStripBrokerOptions} [options] */
+export async function createActivityStripBroker(options = {}) {
+  const broker = new ActivityStripBroker(options);
+  await broker.start();
+  return broker;
+}

package/src/broker/session-store.mjs

@@ -0,0 +1,49 @@
+import { ACTIVITY_STRIP_STALE_AFTER_MS } from "../common/constants.mjs";
+import { normalizeSessionSnapshot, sortSessions } from "../common/protocol.mjs";
+
+/** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
+/** @typedef {import("../common/contracts.ts").SessionStoreOptions} SessionStoreOptions */
+/** @typedef {import("../common/contracts.ts").BrokerSnapshot} BrokerSnapshot */
+
+export class SessionStore {
+  /** @param {SessionStoreOptions} [options] */
+  constructor(options = {}) {
+    this.staleAfterMs = options.staleAfterMs ?? ACTIVITY_STRIP_STALE_AFTER_MS;
+    /** @type {Map<string, SessionSnapshot>} */
+    this.sessions = new Map();
+  }
+
+  /** @param {Partial<SessionSnapshot> | Record<string, unknown>} session */
+  upsert(session) {
+    const normalized = normalizeSessionSnapshot(session);
+    if (!normalized.sessionId) return false;
+    this.sessions.set(normalized.sessionId, normalized);
+    return true;
+  }
+
+  /** @param {string} sessionId */
+  remove(sessionId) {
+    return this.sessions.delete(String(sessionId ?? ""));
+  }
+
+  /** @param {number} [now] */
+  purge(now = Date.now()) {
+    let changed = false;
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (now - session.updatedAt > this.staleAfterMs) {
+        this.sessions.delete(sessionId);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
+  /** @param {number} [now] @returns {BrokerSnapshot} */
+  snapshot(now = Date.now()) {
+    this.purge(now);
+    return {
+      generatedAt: now,
+      sessions: sortSessions([...this.sessions.values()]),
+    };
+  }
+}

package/src/client/broker-client.mjs

@@ -0,0 +1,115 @@
+import net from "node:net";
+/** @typedef {import("../common/contracts.ts").BrokerClientOptions} BrokerClientOptions */
+/** @typedef {import("../common/contracts.ts").BrokerResponse} BrokerResponse */
+/** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
+import {
+  ACTIVITY_STRIP_CONNECT_TIMEOUT_MS,
+  ACTIVITY_STRIP_SOCKET_PATH,
+} from "../common/constants.mjs";
+import { makeMessage } from "../common/protocol.mjs";
+
+/** @param {Record<string, unknown>} message @param {BrokerClientOptions} [options] @returns {Promise<BrokerResponse>} */
+export function sendBrokerMessage(message, options = {}) {
+  const expectReply = Boolean(options.expectReply);
+  const timeoutMs =
+    Number(options.timeoutMs ?? ACTIVITY_STRIP_CONNECT_TIMEOUT_MS) ||
+    ACTIVITY_STRIP_CONNECT_TIMEOUT_MS;
+  const socketPath = options.socketPath ?? ACTIVITY_STRIP_SOCKET_PATH;
+
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let settled = false;
+    let buffer = "";
+
+    /** @param {BrokerResponse} value */
+    const finishResolve = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      socket.destroy();
+      resolve(value);
+    };
+
+    /** @param {Error} error */
+    const finishReject = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      socket.destroy();
+      reject(error);
+    };
+
+    const timeoutId = setTimeout(() => {
+      finishReject(new Error(`Timed out contacting activity strip broker after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    socket.setEncoding("utf8");
+
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(message)}\n`, () => {
+        if (!expectReply) {
+          finishResolve({ ok: true });
+        }
+      });
+    });
+
+    socket.on("data", (chunk) => {
+      if (!expectReply || settled) return;
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex < 0) return;
+      const line = buffer.slice(0, newlineIndex).trim();
+      if (!line) return;
+      try {
+        const parsed = JSON.parse(line);
+        finishResolve(
+          parsed && typeof parsed === "object"
+            ? /** @type {BrokerResponse} */ (parsed)
+            : { ok: false, error: "Invalid broker response payload" },
+        );
+      } catch (error) {
+        finishReject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+
+    socket.on("error", (error) => {
+      finishReject(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+}
+
+/** @param {BrokerClientOptions} [options] */
+export async function getBrokerStatus(options = {}) {
+  return await sendBrokerMessage(makeMessage("ping"), {
+    ...options,
+    expectReply: true,
+  });
+}
+
+/** @param {BrokerClientOptions} [options] */
+export async function isBrokerAlive(options = {}) {
+  try {
+    const result = await getBrokerStatus(options);
+    return result?.ok === true;
+  } catch {
+    return false;
+  }
+}
+
+/** @param {BrokerClientOptions} [options] @returns {Promise<BrokerResponse>} */
+export async function requestBrokerShutdown(options = {}) {
+  return await sendBrokerMessage(makeMessage("shutdown"), {
+    ...options,
+    expectReply: true,
+  });
+}
+
+/** @param {SessionSnapshot} session @param {BrokerClientOptions} [options] */
+export async function publishSessionSnapshot(session, options = {}) {
+  await sendBrokerMessage(makeMessage("upsert", { session }), options);
+}
+
+/** @param {string} sessionId @param {BrokerClientOptions} [options] */
+export async function removeSession(sessionId, options = {}) {
+  await sendBrokerMessage(makeMessage("remove", { sessionId }), options);
+}