pi-microsandbox 0.1.0

package/extensions/pi-msb/footer.ts

@@ -0,0 +1,191 @@
+import {
+  type ContextUsage,
+  type ExtensionContext,
+  type ReadonlyFooterDataProvider,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+const STATUS_KEY = "pi-msb";
+const MIN_GAP = 2;
+
+type UsageLike = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  cost?: { total?: number };
+};
+
+type UsageTotals = Required<Omit<UsageLike, "cost">> & { cost: number };
+
+function formatTokens(count: number): string {
+  if (count < 1_000) return count.toString();
+  if (count < 10_000) return `${(count / 1_000).toFixed(1)}k`;
+  if (count < 1_000_000) return `${Math.round(count / 1_000)}k`;
+  if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(count / 1_000_000)}M`;
+}
+
+function formatCwd(cwd: string, home: string | undefined): string {
+  if (!home) return cwd;
+  const resolvedCwd = resolve(cwd);
+  const resolvedHome = resolve(home);
+  const relativeToHome = relative(resolvedHome, resolvedCwd);
+  const insideHome = relativeToHome === "" || (
+    relativeToHome !== ".." &&
+    !relativeToHome.startsWith(`..${sep}`) &&
+    !isAbsolute(relativeToHome)
+  );
+  if (!insideHome) return cwd;
+  return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
+
+function usageFromEntry(entry: unknown): UsageLike | undefined {
+  if (!entry || typeof entry !== "object") return undefined;
+  const value = entry as {
+    type?: string;
+    usage?: UsageLike;
+    message?: { role?: string; usage?: UsageLike };
+  };
+  if (value.type === "message" && (value.message?.role === "assistant" || value.message?.role === "toolResult")) {
+    return value.message.usage;
+  }
+  if (value.type === "branch_summary" || value.type === "compaction") return value.usage;
+  return undefined;
+}
+
+function totalUsage(entries: readonly unknown[]): { totals: UsageTotals; latestCacheHitRate?: number } {
+  const totals: UsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  let latestCacheHitRate: number | undefined;
+  for (const entry of entries) {
+    const usage = usageFromEntry(entry);
+    if (!usage) continue;
+    totals.input += usage.input ?? 0;
+    totals.output += usage.output ?? 0;
+    totals.cacheRead += usage.cacheRead ?? 0;
+    totals.cacheWrite += usage.cacheWrite ?? 0;
+    totals.cost += usage.cost?.total ?? 0;
+
+    const value = entry as { type?: string; message?: { role?: string } };
+    if (value.type === "message" && value.message?.role === "assistant") {
+      const promptTokens = (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+      latestCacheHitRate = promptTokens > 0 ? ((usage.cacheRead ?? 0) / promptTokens) * 100 : undefined;
+    }
+  }
+  return { totals, latestCacheHitRate };
+}
+
+/** Align two ANSI-styled values while keeping the right value visible. */
+export function alignFooterRow(left: string, right: string, width: number, ellipsis = "..."): string {
+  if (width <= 0) return "";
+  const rightWidth = visibleWidth(right);
+  if (rightWidth >= width) return truncateToWidth(right, width, "");
+  const maxLeftWidth = Math.max(0, width - rightWidth - MIN_GAP);
+  const fittedLeft = truncateToWidth(left, maxLeftWidth, ellipsis);
+  const padding = " ".repeat(Math.max(0, width - visibleWidth(fittedLeft) - rightWidth));
+  return fittedLeft + padding + right;
+}
+
+function sanitizeStatus(text: string): string {
+  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+function isUsingSubscription(ctx: ExtensionContext): boolean {
+  const model = ctx.model;
+  if (!model) return false;
+  if (model.provider === "kimi-coding") return true;
+  const provider = ctx.modelRegistry.getProvider(model.provider);
+  return ctx.modelRegistry.isUsingOAuth(model) && provider?.auth.oauth?.isSubscription === true;
+}
+
+function renderContextUsage(theme: Theme, usage: ContextUsage | undefined, contextWindow: number): string {
+  const percentValue = usage?.percent ?? 0;
+  const percent = usage?.percent === null ? "?" : (usage?.percent ?? 0).toFixed(1);
+  const text = `${percent}%/${formatTokens(usage?.contextWindow ?? contextWindow)}`;
+  if (percentValue > 90) return theme.fg("error", text);
+  if (percentValue > 70) return theme.fg("warning", text);
+  return text;
+}
+
+/** Build a two-row Pi footer with the MSB status in the upper-right corner. */
+export function createMsbFooter(
+  tui: TUI,
+  theme: Theme,
+  ctx: ExtensionContext,
+  footerData: ReadonlyFooterDataProvider,
+): Component & { dispose(): void } {
+  const unsubscribe = footerData.onBranchChange(() => tui.requestRender());
+
+  return {
+    invalidate() {},
+    dispose: unsubscribe,
+    render(width: number): string[] {
+      const statuses = footerData.getExtensionStatuses();
+      const msbStatus = sanitizeStatus(statuses.get(STATUS_KEY) ?? "");
+
+      let location = formatCwd(
+        ctx.sessionManager.getCwd(),
+        process.env.HOME || process.env.USERPROFILE,
+      );
+      const branch = footerData.getGitBranch();
+      if (branch) location += ` (${branch})`;
+      const sessionName = ctx.sessionManager.getSessionName();
+      if (sessionName) location += ` • ${sessionName}`;
+
+      const dimEllipsis = theme.fg("dim", "...");
+      const locationText = theme.fg("dim", location);
+      const locationLine = msbStatus
+        ? alignFooterRow(locationText, msbStatus, width, dimEllipsis)
+        : truncateToWidth(locationText, width, dimEllipsis);
+
+      const { totals, latestCacheHitRate } = totalUsage(ctx.sessionManager.getEntries());
+      const stats: string[] = [];
+      if (totals.input) stats.push(`↑${formatTokens(totals.input)}`);
+      if (totals.output) stats.push(`↓${formatTokens(totals.output)}`);
+      if (totals.cacheRead) stats.push(`R${formatTokens(totals.cacheRead)}`);
+      if (totals.cacheWrite) stats.push(`W${formatTokens(totals.cacheWrite)}`);
+      if ((totals.cacheRead || totals.cacheWrite) && latestCacheHitRate !== undefined) {
+        stats.push(`CH${latestCacheHitRate.toFixed(1)}%`);
+      }
+      const usingSubscription = isUsingSubscription(ctx);
+      if (totals.cost || usingSubscription) {
+        stats.push(`$${totals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
+      }
+      stats.push(renderContextUsage(theme, ctx.getContextUsage(), ctx.model?.contextWindow ?? 0));
+
+      const modelName = ctx.model?.id ?? "no-model";
+      const thinkingLevel = ctx.thinkingLevel ?? "off";
+      const modelAndThinking = ctx.model?.reasoning
+        ? `${modelName} • ${thinkingLevel === "off" ? "thinking off" : thinkingLevel}`
+        : modelName;
+      let modelText = modelAndThinking;
+      if (ctx.model && footerData.getAvailableProviderCount() > 1) {
+        const withProvider = `(${ctx.model.provider}) ${modelAndThinking}`;
+        if (visibleWidth(stats.join(" ")) + MIN_GAP + visibleWidth(withProvider) <= width) modelText = withProvider;
+      }
+      const statsLine = alignFooterRow(
+        theme.fg("dim", stats.join(" ")),
+        theme.fg("dim", modelText),
+        width,
+        dimEllipsis,
+      );
+
+      const lines = [locationLine, statsLine];
+      const otherStatuses = Array.from(statuses.entries())
+        .filter(([key]) => key !== STATUS_KEY)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([, text]) => sanitizeStatus(text));
+      if (otherStatuses.length > 0) {
+        lines.push(truncateToWidth(otherStatuses.join(" "), width, dimEllipsis));
+      }
+      return lines;
+    },
+  };
+}

package/extensions/pi-msb/git.ts

@@ -0,0 +1,256 @@
+import { execFile } from "node:child_process";
+import { chmod, mkdir, mkdtemp, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+
+import type { ExecFn, GitRepoInfo, GitSeedBundle } from "./types.ts";
+
+const execFileAsync = promisify(execFile);
+const SEED_REF = "refs/pi-msb/seed";
+
+interface ExecFileFailure {
+  code?: number | string;
+  killed?: boolean;
+  signal?: string | null;
+  stdout?: string | Buffer;
+  stderr?: string | Buffer;
+  message?: string;
+}
+
+/** Execute a program without giving it a shell or interpolating its arguments. */
+const defaultExec: ExecFn = async (command, args, options = {}) => {
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      timeout: options.timeout === undefined ? undefined : options.timeout * 1000,
+      maxBuffer: 16 * 1024 * 1024,
+      encoding: "utf8",
+    });
+    return {
+      stdout: String(result.stdout),
+      stderr: String(result.stderr),
+      code: 0,
+    };
+  } catch (error: unknown) {
+    const failure = error as ExecFileFailure;
+    const numericCode = typeof failure.code === "number" ? failure.code : 127;
+    return {
+      stdout: String(failure.stdout ?? ""),
+      stderr: String(failure.stderr ?? failure.message ?? ""),
+      code: numericCode,
+      killed: Boolean(failure.killed || failure.signal),
+    };
+  }
+};
+
+const emptyRepo = (hostCwd?: string): GitRepoInfo => ({
+  isGitRepo: false,
+  ...(hostCwd ? { hostCwd } : {}),
+  repoRoot: null,
+  branch: null,
+  headSha: null,
+  unborn: false,
+  isLinkedWorktree: false,
+});
+
+function output(result: Awaited<ReturnType<ExecFn>>): string {
+  return result.stdout.trim();
+}
+
+function failureMessage(context: string, result: Awaited<ReturnType<ExecFn>>): Error {
+  const detail = result.stderr.trim() || `git exited with code ${result.code}`;
+  return new Error(`${context}: ${detail}`);
+}
+
+async function canonicalPath(value: string): Promise<string> {
+  try {
+    return await realpath(value);
+  } catch {
+    return resolve(value);
+  }
+}
+
+function pathFromGitResult(value: string, base: string): string {
+  return isAbsolute(value) ? value : resolve(base, value);
+}
+
+async function lexicalRepoRoot(requestedCwd: string, canonicalRepoRoot: string): Promise<string | null> {
+  let candidate = requestedCwd;
+  while (true) {
+    if (await canonicalPath(candidate) === canonicalRepoRoot) return candidate;
+    const parent = dirname(candidate);
+    if (parent === candidate) return null;
+    candidate = parent;
+  }
+}
+
+/**
+ * Return the immutable source state of cwd. A directory outside Git is an ordinary
+ * result rather than an error, which lets storage mode `auto` remain a direct alias.
+ */
+export async function detectGitRepo(cwd: string, exec: ExecFn = defaultExec): Promise<GitRepoInfo> {
+  const requestedCwd = resolve(cwd);
+  const hostCwd = await canonicalPath(requestedCwd);
+  const topLevel = await exec("git", ["-C", requestedCwd, "rev-parse", "--show-toplevel"]);
+  if (topLevel.code !== 0 || topLevel.killed || !output(topLevel)) return emptyRepo(hostCwd);
+
+  const repoRoot = await canonicalPath(output(topLevel));
+  const guestRepoRoot = await lexicalRepoRoot(requestedCwd, repoRoot);
+  const branchResult = await exec("git", [
+    "-C",
+    repoRoot,
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    "HEAD",
+  ]);
+  const branch = branchResult.code === 0 && !branchResult.killed && output(branchResult)
+    ? output(branchResult)
+    : null;
+
+  const headResult = await exec("git", ["-C", repoRoot, "rev-parse", "--verify", "HEAD"]);
+  const headSha = headResult.code === 0 && !headResult.killed && output(headResult)
+    ? output(headResult)
+    : null;
+
+  // In a linked worktree --git-dir points at .git/worktrees/<name>, while
+  // --git-common-dir points at the shared .git directory.
+  const gitDirResult = await exec("git", ["-C", repoRoot, "rev-parse", "--git-dir"]);
+  const commonDirResult = await exec("git", ["-C", repoRoot, "rev-parse", "--git-common-dir"]);
+  let isLinkedWorktree = false;
+  if (gitDirResult.code === 0 && commonDirResult.code === 0) {
+    const gitDir = await canonicalPath(pathFromGitResult(output(gitDirResult), repoRoot));
+    const commonDir = await canonicalPath(pathFromGitResult(output(commonDirResult), repoRoot));
+    isLinkedWorktree = gitDir !== commonDir;
+  }
+
+  return {
+    isGitRepo: true,
+    hostCwd,
+    repoRoot,
+    guestRepoRoot,
+    branch,
+    headSha,
+    unborn: headSha === null && branch !== null,
+    isLinkedWorktree,
+  };
+}
+
+function bundleFailure(context: string, result: Awaited<ReturnType<ExecFn>>): never {
+  throw failureMessage(context, result);
+}
+
+async function checkedGit(
+  exec: ExecFn,
+  args: string[],
+  context: string,
+): Promise<Awaited<ReturnType<ExecFn>>> {
+  const result = await exec("git", args);
+  if (result.code !== 0 || result.killed) bundleFailure(context, result);
+  return result;
+}
+
+/**
+ * Make a disposable bundle from committed objects only. The temporary bare clone
+ * deliberately has no worktree, so ignored, modified, and untracked files cannot
+ * enter the seed.
+ */
+export async function createSeedBundle(
+  info: GitRepoInfo,
+  options: {
+    branch: "current" | string;
+    depth: number | "unlimited";
+    tempRoot?: string;
+    exec?: ExecFn;
+  },
+): Promise<GitSeedBundle | null> {
+  if (!info.isGitRepo || info.unborn || !info.repoRoot || !info.headSha) return null;
+  if (options.depth !== "unlimited" && (!Number.isInteger(options.depth) || options.depth < 1)) {
+    throw new Error(`invalid Git bundle depth: ${String(options.depth)}`);
+  }
+
+  const exec = options.exec ?? defaultExec;
+  const parent = resolve(options.tempRoot ?? tmpdir());
+  await mkdir(parent, { recursive: true, mode: 0o700 });
+  const tempDir = await mkdtemp(join(parent, "pi-msb-git-"));
+  await chmod(tempDir, 0o700);
+  let cleaned = false;
+  const cleanup = async (): Promise<void> => {
+    if (cleaned) return;
+    cleaned = true;
+    await rm(tempDir, { recursive: true, force: true });
+  };
+
+  try {
+    const bareName = "source.git";
+    const barePath = join(tempDir, bareName);
+    const bundlePath = join(tempDir, "seed.bundle");
+    const source = fileUrl(info.repoRoot);
+    const depthArgs = options.depth === "unlimited" ? [] : ["--depth", String(options.depth)];
+
+    // A file:// URL forces Git's local transport while keeping the source repo
+    // read-only. --bare means no checkout, filters, or worktree are involved.
+    await checkedGit(
+      exec,
+      ["-C", tempDir, "clone", "--bare", "--no-tags", ...depthArgs, source, bareName],
+      "creating temporary bare clone",
+    );
+
+    const objectCheck = await exec("git", ["-C", barePath, "cat-file", "-e", `${info.headSha}^{commit}`]);
+    if (objectCheck.code !== 0 || objectCheck.killed) {
+      // A branch may have moved between detection and clone. Fetch the captured
+      // object explicitly; never fall back to whatever HEAD the clone obtained.
+      await checkedGit(
+        exec,
+        ["-C", barePath, "fetch", "--no-tags", ...depthArgs, source, info.headSha],
+        `fetching captured HEAD ${info.headSha}`,
+      );
+    }
+
+    const verifiedObject = await exec("git", ["-C", barePath, "cat-file", "-e", `${info.headSha}^{commit}`]);
+    if (verifiedObject.code !== 0 || verifiedObject.killed) {
+      bundleFailure(`captured HEAD ${info.headSha} is not present in temporary clone`, verifiedObject);
+    }
+
+    await checkedGit(
+      exec,
+      ["-C", barePath, "update-ref", SEED_REF, info.headSha],
+      "updating temporary seed ref",
+    );
+    await checkedGit(
+      exec,
+      ["-C", barePath, "bundle", "create", bundlePath, SEED_REF],
+      "creating Git bundle",
+    );
+    await checkedGit(exec, ["-C", barePath, "bundle", "verify", bundlePath], "verifying Git bundle");
+    const heads = await checkedGit(
+      exec,
+      ["-C", barePath, "bundle", "list-heads", bundlePath],
+      "listing Git bundle heads",
+    );
+    const expectedHead = heads.stdout
+      .split(/\r?\n/)
+      .map((line) => line.trim().split(/\s+/))
+      .find(([sha, ref]) => sha === info.headSha && ref === SEED_REF);
+    if (!expectedHead) {
+      throw new Error(`Git bundle did not contain captured HEAD ${info.headSha} at ${SEED_REF}`);
+    }
+
+    return {
+      hostPath: bundlePath,
+      branch: options.branch === "current" ? info.branch : options.branch,
+      headSha: info.headSha,
+      cleanup,
+    };
+  } catch (error: unknown) {
+    await cleanup().catch(() => undefined);
+    throw error;
+  }
+}
+
+export function fileUrl(path: string): string {
+  return pathToFileURL(path).href;
+}

package/extensions/pi-msb/index.ts

@@ -0,0 +1,156 @@
+import {
+  CONFIG_DIR_NAME,
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  truncateHead,
+  truncateLine,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { createHostReadAccess } from "./skill-access.ts";
+import { createSandboxGrepExecute } from "./operations-exec.ts";
+import { registerMsbCommand, systemPromptNote } from "./command.ts";
+import { createMsbIntegration } from "./control.ts";
+import { createMsbFooter } from "./footer.ts";
+import { registerSandboxTools } from "./tools.ts";
+import type { ResolvedConfig, RuntimeState } from "./types.ts";
+
+export function footerStatus(state: RuntimeState, visible: boolean): string | undefined {
+  if (!visible) return undefined;
+  switch (state.status) {
+    case "active": return `msb-${state.info?.displayId ?? "active"}`;
+    case "off": return "MSB host";
+    case "host-fallback": return "MSB host fallback";
+    case "unavailable": return "MSB blocked";
+    case "booting": return "(msb) preparing sandbox...";
+    case "stopping": return "MSB stopping";
+    default: return "MSB disabled";
+  }
+}
+
+/**
+ * The extension entry point intentionally imports no native SDK. Loading this
+ * module must remain safe on hosts without KVM or the microsandbox binary;
+ * control.ts calls import("microsandbox") only when a session actually boots.
+ */
+export default function registerPiMsb(pi: ExtensionAPI): void {
+  const hostReads = createHostReadAccess();
+  const integration = createMsbIntegration({
+    sessionId: "uninitialized",
+    cwd: process.cwd(),
+    configDirName: CONFIG_DIR_NAME,
+    env: process.env,
+    appendEntry: (customType, data) => pi.appendEntry(customType, data),
+    entries: () => currentContext?.sessionManager.getEntries() ?? [],
+    onState: (state) => {
+      if (currentContext) updateStatus(currentContext, state);
+    },
+  });
+  const currentProvider = integration.provider;
+  let currentContext: ExtensionContext | undefined;
+  let lastConfig: ResolvedConfig = integration.control.getEffectiveConfig();
+  let bootAnimation: ReturnType<typeof setInterval> | undefined;
+  let customFooterInstalled = false;
+
+  const styleFooterStatus = (ctx: ExtensionContext, text: string): string =>
+    `\x1b[22m${ctx.ui.theme.fg("dim", text)}\x1b[22m`;
+
+  const stopBootAnimation = (): void => {
+    if (bootAnimation !== undefined) {
+      clearInterval(bootAnimation);
+      bootAnimation = undefined;
+    }
+  };
+
+  const startBootAnimation = (ctx: ExtensionContext): void => {
+    if (bootAnimation !== undefined) return;
+    const frames = [
+      "(msb) preparing sandbox.",
+      "(msb) preparing sandbox..",
+      "(msb) preparing sandbox...",
+    ];
+    let frame = 0;
+    const render = (): void => {
+      ctx.ui.setStatus("pi-msb", styleFooterStatus(ctx, frames[frame]));
+      frame = (frame + 1) % frames.length;
+    };
+    render();
+    bootAnimation = setInterval(render, 400);
+  };
+
+  const ensureCustomFooter = (ctx: ExtensionContext): void => {
+    if (customFooterInstalled) return;
+    ctx.ui.setFooter((tui, theme, footerData) => createMsbFooter(tui, theme, ctx, footerData));
+    customFooterInstalled = true;
+  };
+
+  const updateStatus = (ctx: ExtensionContext, state: RuntimeState): void => {
+    const text = footerStatus(state, integration.configRef.value.showFooter);
+    if (text !== undefined) ensureCustomFooter(ctx);
+    if (text === undefined) {
+      stopBootAnimation();
+      ctx.ui.setStatus("pi-msb", undefined);
+      return;
+    }
+    if (state.status === "booting") {
+      startBootAnimation(ctx);
+      return;
+    }
+    stopBootAnimation();
+    ctx.ui.setStatus("pi-msb", styleFooterStatus(ctx, text));
+  };
+
+  registerSandboxTools(pi, {
+    provider: currentProvider,
+    config: integration.configRef.value,
+    cwd: process.cwd(),
+    hostReads,
+    createGrepExecute: ({ provider, cwd, grepHelpers }) =>
+      createSandboxGrepExecute({ provider, cwd, helpers: grepHelpers }),
+    grepHelpers: { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateHead: truncateHead as (content: string, options?: unknown) => any, truncateLine, formatSize },
+    systemPromptNote,
+  });
+  registerMsbCommand(pi, integration.control);
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentContext = ctx;
+    updateStatus(ctx, { status: "booting", info: null });
+    try {
+      // configureSession performs Git discovery before project config resolution,
+      // so trust and the nearest project file are evaluated against the real root.
+      const state = await integration.configureSession({
+        sessionId: ctx.sessionManager.getSessionId(),
+        cwd: ctx.cwd,
+        projectTrusted: ctx.isProjectTrusted(),
+        restored: undefined,
+      });
+      lastConfig = integration.control.getEffectiveConfig();
+      updateStatus(ctx, state);
+      for (const warning of lastConfig.warnings) ctx.ui.notify(`pi-microsandbox: ${warning}`, "warning");
+    } catch (error) {
+      // Invalid config and native boot failures are fail-closed. Do not throw from
+      // the lifecycle hook: Pi remains usable and routed tools remain blocked.
+      updateStatus(ctx, { status: "unavailable", info: null });
+      ctx.ui.notify(`pi-microsandbox unavailable: ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    stopBootAnimation();
+    await integration.manager.shutdown();
+    hostReads.clear();
+    ctx.ui.setStatus("pi-msb", undefined);
+    // Pi tears down extension-owned UI after this hook. Do not call
+    // setFooter(undefined): another extension may have replaced our footer.
+    currentContext = undefined;
+  });
+
+  // The tools module owns the skill capture hook. This handler only keeps the
+  // footer in sync after transitions initiated by commands or reload.
+  pi.on("session_info_changed", () => {
+    if (currentContext) updateStatus(currentContext, integration.control.getState());
+  });
+
+  void lastConfig;
+}