@xpufx/paseo-helper-demo 0.2.0

package/client/vendor/paseo-plugin-helper/ui/modal.tsx

@@ -0,0 +1,105 @@
+import React, { type ReactNode } from "react";
+import {
+  ScrollView as FallbackScrollView,
+  StyleSheet,
+  View,
+  type StyleProp,
+  type ViewStyle,
+} from "react-native";
+import {
+  getClientHost,
+  getOptionalClientHost,
+  selectHostScrollView,
+  type HostScrollView,
+} from "../host";
+
+/**
+ * Host-delegating modal content for `paseo-plugin-helper/ui`.
+ *
+ * Contract — ONLY for content rendered directly inside your OWN host
+ * `<Modal>` (e.g. x-comms style own-modal surfaces):
+ * - Scroll ownership stays with the host: renders the injected host
+ *   `<Modal.Content>` with its default `scrollable` behavior and adds NO
+ *   helper-owned scroller, so sheet gestures, keyboard avoidance, and
+ *   safe-area clearance keep working on compact/mobile and desktop alike.
+ * - No width opinions: there is deliberately NO `maxContentWidth` /
+ *   `size="large"` prop. The host allocates the dialog frame; this wrapper
+ *   fills it fluidly (`width: "100%"`).
+ * - No theme scraping: colors come from the host `theme` prop via
+ *   `PluginThemeProvider`, never from DOM CSS variables.
+ * - NEVER render this inside `registerComposerPill` `renderModal`: the pill
+ *   host already provides the one `<Modal.Content>` (or no modal at all on
+ *   0.8 popovers), so a nested `<Modal.Content>` violates the host contract
+ *   and crashes the plugin. Use `HostModalSection` there instead.
+ */
+export function HostModalContent({
+  children,
+  style,
+  contentContainerStyle,
+}: {
+  children: ReactNode;
+  style?: StyleProp<ViewStyle>;
+  contentContainerStyle?: StyleProp<ViewStyle>;
+}) {
+  const { Modal } = getClientHost();
+  return (
+    <Modal.Content>
+      <View style={[styles.fluid, style, contentContainerStyle]}>{children}</View>
+    </Modal.Content>
+  );
+}
+
+/**
+ * Explicit single scroll owner for surfaces where the host supplies NO
+ * scroller (sidebar surfaces, settings screens). Prefers the injected host
+ * ScrollView (sheet-gesture integrated on Paseo v0.8) and falls back to plain
+ * React Native ScrollView. Callers own the decision to scroll; this component
+ * never nests itself inside another scroller.
+ */
+export function HostScroll({
+  children,
+  style,
+  contentContainerStyle,
+}: {
+  children: ReactNode;
+  style?: StyleProp<ViewStyle>;
+  contentContainerStyle?: StyleProp<ViewStyle>;
+}) {
+  const ResolvedScrollView = selectHostScrollView(
+    getOptionalClientHost(),
+    FallbackScrollView as unknown as HostScrollView,
+  );
+  return (
+    <ResolvedScrollView style={[styles.fluid, style]} contentContainerStyle={contentContainerStyle}>
+      {children}
+    </ResolvedScrollView>
+  );
+}
+
+const styles = StyleSheet.create({
+  fluid: {
+    width: "100%",
+  },
+});
+
+/**
+ * Fluid inner content for pill-embedded modals (`registerComposerPill`
+ * `renderModal`).
+ *
+ * The pill host already provides the one `<Modal.Content>` (legacy/centered
+ * modal paths) or no modal at all (0.8 popover path, where the host owns the
+ * outer scroll). This renders a plain fluid `<View>` — no `<Modal.Content>`,
+ * no scroller, no width caps — so exactly one `<Modal.Content>` exists and
+ * nothing nests. Pair with `hostScroll: true` on the pill registration so
+ * the wrapper leaves scrolling to the host; without it the wrapper bounds
+ * the dialog (`scrollable={false}`) for legacy `ModalBody` content.
+ */
+export function HostModalSection({
+  children,
+  style,
+}: {
+  children: ReactNode;
+  style?: StyleProp<ViewStyle>;
+}) {
+  return <View style={[styles.fluid, style]}>{children}</View>;
+}

package/client/vendor/paseo-plugin-helper/ui/settings.ts

@@ -0,0 +1,36 @@
+/**
+ * Paseo Plugin Helper — Settings UI adapters.
+ *
+ * These re-export the bundle-driven settings renderer from `client/`, whose
+ * entire contract is already upstream-shaped: the caller passes the host's
+ * native `@getpaseo/plugin/client/ui` primitives
+ * (`SettingsSection`, `SettingsCard`, `SettingsSwitch`, `SettingsSelect`,
+ * `SettingsInput`) as the `ui` bundle, and the helper only maps a zod
+ * settings contract to fields — no bespoke switches, rows, or cards.
+ *
+ * ```tsx
+ * import * as UpstreamUi from "@getpaseo/plugin/client/ui";
+ * registerHelperSettingsScreen(client, contract, { ui: UpstreamUi });
+ * ```
+ */
+
+export {
+  contractSchemaToFields,
+  registerHelperSettingsScreen,
+} from "../settings-screen";
+export type {
+  HelperSettingsUiBundle,
+  HelperSettingsCardProps,
+  HelperSettingsSectionProps,
+  HelperSettingsRowBaseProps,
+  HelperSettingsSwitchProps,
+  HelperSettingsSelectProps,
+  HelperSettingsInputProps,
+  HelperSettingsSelectComponent,
+  HelperSettingsScreenContribution,
+  HelperSettingsScreenRegistrar,
+  HelperSettingsFieldKind,
+  HelperSettingsField,
+  HelperSettingsFieldOverrides,
+  RegisterHelperSettingsScreenOptions,
+} from "../settings-screen";

package/client/vendor/paseo-plugin-helper/utils/clipboard.ts

@@ -0,0 +1,149 @@
+import type { HostToast } from "../host";
+import { getOptionalClientHost } from "../host";
+
+export interface CopyToClipboardOptions {
+  toast?: HostToast;
+  toastMessage?: string;
+}
+
+export type ClipboardTier = "navigator" | "host" | "rnAsync" | "rnSync" | "execCommand";
+
+export interface ClipboardEnvironment {
+  hasNavigatorClipboard: boolean;
+  hasHostCopyText: boolean;
+  hasRnClipboard: boolean;
+  hasRnSetStringAsync: boolean;
+  isDom: boolean;
+}
+
+/**
+ * Deterministic tier order for an explicit copy.
+ *
+ * Web's `navigator.clipboard.writeText` is the only API that rejects when the
+ * clipboard did not change, so it leads. The synchronous
+ * `react-native-web` `Clipboard.setString` reports success even when its
+ * `document.execCommand("copy")` fails, which leaves the previous clipboard
+ * item in place while the UI claims success (xpufx-org/paseo#278); it is only
+ * usable off-DOM (native), where it is the real platform clipboard. In a DOM
+ * the checked `execCommand` fallback is preferred to that unverifiable path.
+ */
+export function clipboardTierOrder(env: ClipboardEnvironment): ClipboardTier[] {
+  const tiers: ClipboardTier[] = [];
+  if (env.hasNavigatorClipboard) tiers.push("navigator");
+  if (env.hasHostCopyText) tiers.push("host");
+  if (env.hasRnSetStringAsync) {
+    tiers.push("rnAsync");
+  } else if (env.hasRnClipboard && !env.isDom) {
+    tiers.push("rnSync");
+  }
+  tiers.push("execCommand");
+  return tiers;
+}
+
+/**
+ * Robust cross-platform clipboard copy helper for Paseo plugins.
+ * Works seamlessly across React Native (mobile), web, and desktop.
+ *
+ * Tier order comes from `clipboardTierOrder`; every tier reports failure
+ * honestly so a denied or blocked write never leaves the previous clipboard
+ * item behind under a fake success.
+ */
+export async function copyToClipboard(
+  text: string,
+  options?: CopyToClipboardOptions,
+): Promise<boolean> {
+  if (text === null || text === undefined) return false;
+  const str = String(text);
+
+  const globalObj = typeof globalThis !== "undefined" ? (globalThis as any) : {};
+
+  let rn: any;
+  try {
+    rn = require("react-native");
+  } catch {
+    // Ignore require error if not in RN context
+  }
+  const rnClipboard = rn?.Clipboard;
+  const rnSetStringAsync =
+    typeof rnClipboard?.setStringAsync === "function" ? rnClipboard.setStringAsync : undefined;
+  const rnSetString =
+    typeof rnClipboard?.setString === "function" ? rnClipboard.setString : undefined;
+  const copyText = getOptionalClientHost()?.copyText;
+
+  const isDom =
+    typeof globalObj.document !== "undefined" &&
+    typeof globalObj.document?.createElement === "function";
+
+  const tiers = clipboardTierOrder({
+    hasNavigatorClipboard: Boolean(globalObj.navigator?.clipboard?.writeText),
+    hasHostCopyText: Boolean(copyText),
+    hasRnClipboard: Boolean(rnSetStringAsync ?? rnSetString),
+    hasRnSetStringAsync: Boolean(rnSetStringAsync),
+    isDom,
+  });
+
+  let success = false;
+  for (const tier of tiers) {
+    if (success) break;
+    try {
+      switch (tier) {
+        case "navigator":
+          await globalObj.navigator.clipboard.writeText(str);
+          success = true;
+          break;
+        case "host":
+          if (copyText) {
+            await copyText(str);
+            success = true;
+          }
+          break;
+        case "rnAsync":
+          // Expo's async API returns a boolean; a rejected promise falls through.
+          success = (await rnSetStringAsync(str)) !== false;
+          break;
+        case "rnSync":
+          // Only reached off-DOM, where this is the native platform clipboard.
+          rnSetString(str);
+          success = true;
+          break;
+        case "execCommand": {
+          const doc = globalObj.document;
+          if (doc?.createElement && doc?.body) {
+            const textarea = doc.createElement("textarea");
+            textarea.value = str;
+            textarea.style.position = "fixed";
+            textarea.style.opacity = "0";
+            textarea.style.left = "-9999px";
+            doc.body.appendChild(textarea);
+            textarea.focus();
+            textarea.select();
+            const res = doc.execCommand("copy");
+            doc.body.removeChild(textarea);
+            success = res === true;
+          }
+          break;
+        }
+      }
+    } catch {
+      // Tier failed; try the next one.
+    }
+  }
+
+  if (success && options?.toast) {
+    try {
+      const toastAny = options.toast as any;
+      if (typeof toastAny.copied === "function") {
+        toastAny.copied(options.toastMessage);
+      } else if (typeof toastAny.show === "function") {
+        const msg = options.toastMessage
+          ? `Copied ${options.toastMessage} to clipboard`
+          : "Copied to clipboard";
+        toastAny.show(msg, { variant: "success" });
+      }
+    } catch {
+      // Ignore toast failure
+    }
+  }
+
+  return success;
+}

package/client/vendor/paseo-plugin-helper/utils/haptics.ts

@@ -0,0 +1,34 @@
+export type HapticFeedbackType =
+  | "light"
+  | "medium"
+  | "heavy"
+  | "success"
+  | "warning"
+  | "error";
+
+const PATTERNS: Record<HapticFeedbackType, number | number[]> = {
+  light: 10,
+  medium: 25,
+  heavy: 45,
+  success: [15, 40, 20],
+  warning: [30, 50, 30],
+  error: [40, 60, 40, 60, 40],
+};
+
+/**
+ * Cross-platform haptic feedback helper for Paseo plugins.
+ * Supports web vibration API and graceful fallback when vibration is unavailable.
+ */
+export function triggerHaptic(type: HapticFeedbackType = "light"): boolean {
+  try {
+    const globalObj = typeof globalThis !== "undefined" ? (globalThis as any) : {};
+    const nav = globalObj.navigator;
+    if (typeof nav?.vibrate === "function") {
+      const pattern = PATTERNS[type] ?? 15;
+      return Boolean(nav.vibrate(pattern));
+    }
+  } catch {
+    // Ignore environments where vibration permissions are denied or unavailable
+  }
+  return false;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@xpufx/paseo-helper-demo",
+  "private": false,
+  "license": "MIT",
+  "version": "0.2.0",
+  "scripts": {
+    "stamp": "node -e \"import('./server/vendor/paseo-plugin-helper/version.ts').then(m => m.stampVersion({ targetFile: 'shared/version.ts' }))\"",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@getpaseo/plugin": "0.9.0-beta.2",
+    "@tanstack/react-query": "^5.90.11",
+    "@types/react": "^19.0.10",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "typescript": "^5.9.3",
+    "zod": "^4.4.3"
+  },
+  "files": [
+    "paseo-plugin.json",
+    "README.md",
+    "LICENSE",
+    "client",
+    "server",
+    "shared",
+    "!**/*.test.ts",
+    "!**/*.test.tsx",
+    "!**/*.test.mjs",
+    "!**/.DS_Store"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xpufx/paseo.git"
+  }
+}

package/paseo-plugin.json

@@ -0,0 +1,6 @@
+{
+  "id": "paseo-helper-demo",
+  "requirements": {
+    "paseo": ">=0.8.0"
+  }
+}

package/server/demo.ts

@@ -0,0 +1,195 @@
+import {
+  createPluginLogger,
+  createPeriodicTask,
+  findAvailablePort,
+  getSystemMetrics,
+  getAgentIdentity,
+  PluginStorage,
+  createSettingsHandlers,
+  createWorkspaceBeacon,
+  type BeaconDaemonClient,
+} from "paseo-plugin-helper/server";
+import type { PluginHandlerContext } from "@getpaseo/plugin/server";
+import { demoSettingsContract, type DemoData, type DemoSettings } from "../shared/demo.js";
+import { PLUGIN_VERSION } from "../shared/version.js";
+
+export const log = createPluginLogger("helper-demo");
+
+export const demoStorage = new PluginStorage<DemoSettings>("helper-demo", "settings.json", {
+  schema: demoSettingsContract.schema,
+});
+
+export const settingsHandlers = createSettingsHandlers(demoSettingsContract, demoStorage, {
+  onUpdate: (newSettings) => {
+    log.info("Demo settings updated via RPC:", newSettings);
+  },
+  onReset: () => {
+    log.info("Demo settings reset to default values");
+  },
+});
+
+let daemonPort = 4280;
+let backgroundTicks = 0;
+
+findAvailablePort(4280, 20).then((port) => {
+  daemonPort = port;
+  log.info(`Showcase demo background service verified on port: ${port}`);
+});
+
+export const backgroundWorker = createPeriodicTask({
+  intervalMs: 3000,
+  runImmediately: true,
+  task: () => {
+    backgroundTicks++;
+  },
+  onError: (err) => {
+    log.error("Periodic background task error:", err);
+  },
+});
+
+export function handleGetDemoData(): DemoData {
+  const metrics = getSystemMetrics();
+
+  return {
+    version: PLUGIN_VERSION,
+    hostname: metrics.hostname,
+    platform: metrics.platform,
+    cpuModel: metrics.cpu.model,
+    cpuUsagePercent: metrics.cpu.usagePercent,
+    memoryUsedPercent: Math.round(metrics.memory.usedPercent),
+    memoryUsedBytes: metrics.memory.usedBytes,
+    memoryTotalBytes: metrics.memory.totalBytes,
+    loadAvg: metrics.cpu.loadAverage,
+    uptimeSeconds: metrics.uptimeSeconds,
+    daemonPort,
+    backgroundTicks,
+    items: [
+      { id: "1", name: "Core Agent Supervisor", category: "Core", status: "running", loadPercent: 14 },
+      { id: "2", name: "Vector Index Pipeline", category: "Data", status: "syncing", loadPercent: 48 },
+      { id: "3", name: "MCP Tool Gateway", category: "Network", status: "running", loadPercent: 6 },
+      { id: "4", name: "Local Disk Compactor", category: "Storage", status: "idle", loadPercent: 0 },
+      { id: "5", name: "Peer Gossip Protocol", category: "Network", status: "warning", loadPercent: 82 },
+    ],
+  };
+}
+
+export function handleTriggerDemoAction(input: { actionName: string }) {
+  log.info(`Received demo action: "${input.actionName}" at tick ${backgroundTicks}`);
+  return {
+    success: true,
+    message: `Triggered action "${input.actionName}" (Worker tick #${backgroundTicks})`,
+  };
+}
+
+export async function handleGetAgentIdentity() {
+  const identity = await getAgentIdentity();
+  return { identity };
+}
+
+export const demoBeacon = createWorkspaceBeacon();
+
+function extractDaemonClient(paseo: PluginHandlerContext["paseo"]): BeaconDaemonClient | null {
+  const candidate = paseo as unknown as Record<string, unknown>;
+  if (typeof candidate["setWorkspaceLabel"] === "function") {
+    return candidate as unknown as BeaconDaemonClient;
+  }
+  for (const key of ["daemonClient", "client", "daemon"]) {
+    const nested = candidate[key] as Record<string, unknown> | undefined;
+    if (nested && typeof nested["setWorkspaceLabel"] === "function") {
+      return nested as unknown as BeaconDaemonClient;
+    }
+  }
+  return paseo as unknown as BeaconDaemonClient;
+}
+
+function wireBeaconForWorkspace(paseo: PluginHandlerContext["paseo"], workspaceId: string): void {
+  demoBeacon.setOptions({
+    workspaceHandle: {
+      setTitle: (title: string) => paseo.workspaces.ref(workspaceId).setTitle(title),
+    },
+    daemonClient: extractDaemonClient(paseo),
+  });
+}
+
+async function resolveBaseTitle(
+  paseo: PluginHandlerContext["paseo"],
+  workspaceId: string,
+): Promise<void> {
+  if (demoBeacon.hasOriginalTitle(workspaceId)) {
+    return;
+  }
+  try {
+    const handle = paseo.workspaces.ref(workspaceId);
+    const snapshot = handle.current() ?? (await handle.refresh());
+    let rawTitle = (snapshot as { title?: unknown; name?: unknown } | null)?.title;
+    if (typeof rawTitle !== "string" || rawTitle.trim().length === 0) {
+      rawTitle = (snapshot as { name?: unknown } | null)?.name as string | undefined;
+    }
+    if (typeof rawTitle === "string" && rawTitle.trim().length > 0) {
+      // Strip any leftover beacon suffix if present from previous run
+      const cleaned = rawTitle.replace(/\s*[●🟢🟠○◉].*$/, "").trim();
+      const finalTitle = cleaned.length > 0 ? cleaned : rawTitle;
+      demoBeacon.setOriginalTitle(workspaceId, finalTitle);
+      demoBeacon.setOptions({ baseTitle: finalTitle });
+    }
+  } catch {
+    // Best-effort only; beacon falls back to stored/original title.
+  }
+}
+
+export async function handleDemoBeaconSet(
+  input: { workspaceId: string; name: string; color: string },
+  context: PluginHandlerContext,
+) {
+  wireBeaconForWorkspace(context.paseo, input.workspaceId);
+  await resolveBaseTitle(context.paseo, input.workspaceId);
+  const result = await demoBeacon.set({
+    workspaceId: input.workspaceId,
+    name: input.name,
+    color: input.color,
+    titleSuffix: ` 🟢 ${input.name}`,
+  });
+  log.info(`Demo beacon set "${input.name}" (${input.color}) on ${input.workspaceId}`);
+  return {
+    success: true,
+    message: `Beacon "${input.name}" (${input.color}) applied`,
+    labelApplied: result.labelApplied,
+    titleApplied: result.titleApplied,
+  };
+}
+
+export async function handleDemoBeaconBlink(
+  input: { workspaceId: string; rounds: number },
+  context: PluginHandlerContext,
+) {
+  wireBeaconForWorkspace(context.paseo, input.workspaceId);
+  await resolveBaseTitle(context.paseo, input.workspaceId);
+  demoBeacon.blink({
+    workspaceId: input.workspaceId,
+    a: { name: "DEMO:ACTIVE", color: "emerald", titleSuffix: " 🟢 RUNNING" },
+    b: { name: "DEMO:WAITING", color: "orange", titleSuffix: " 🟠 WAITING" },
+    intervalMs: 1000,
+    rounds: input.rounds,
+    restoreOnDone: true,
+  });
+  log.info(`Demo beacon blink started on ${input.workspaceId} for ${input.rounds} rounds`);
+  return {
+    success: true,
+    message: `Beacon blinking 🟢 RUNNING <-> 🟠 WAITING for ${input.rounds} rounds (auto-restores)`,
+  };
+}
+
+export async function handleDemoBeaconClear(
+  input: { workspaceId: string; name: string },
+  context: PluginHandlerContext,
+) {
+  wireBeaconForWorkspace(context.paseo, input.workspaceId);
+  const result = await demoBeacon.clear({ workspaceId: input.workspaceId, name: input.name });
+  log.info(`Demo beacon cleared on ${input.workspaceId}`);
+  return {
+    success: true,
+    message: "Beacon cleared, original title restored",
+    labelCleared: result.labelCleared,
+    titleRestored: result.titleRestored,
+  };
+}

package/server/suite-settings.ts

@@ -0,0 +1,23 @@
+import { createSharedPluginSettings } from "paseo-plugin-helper/server";
+import {
+  SuiteSettingsContract,
+  SuiteSettingsSchema,
+  type SuiteSettings,
+} from "paseo-plugin-helper/shared";
+import { log } from "./demo.js";
+
+export const suiteSettings = createSharedPluginSettings<SuiteSettings>({
+  suite: "xpufx-suite",
+  schema: SuiteSettingsSchema,
+  contract: SuiteSettingsContract,
+  description: "Shared xpufx suite settings (demo plugin side)",
+});
+
+export const suiteSettingsHandlers = suiteSettings.createHandlers({
+  onUpdate: (next) => {
+    log.info("Shared suite settings updated via demo plugin:", next);
+  },
+  onReset: () => {
+    log.info("Shared suite settings reset via demo plugin");
+  },
+});

package/server/vendor/paseo-plugin-helper/agent.ts

@@ -0,0 +1,85 @@
+import { safeExec } from "./process";
+
+export interface AgentIdentity {
+  id?: string;
+  name?: string;
+  model?: string;
+  provider?: string;
+  repo?: string;
+  branch?: string;
+  envelopeText?: string;
+}
+
+export interface AgentIdentityOptions {
+  timeoutMs?: number;
+  envelopeCommand?: string;
+}
+
+const ENV_KEYS = [
+  "AGENT_ID",
+  "AGENT_NAME",
+  "AGENT_MODEL",
+  "AGENT_PROVIDER",
+  "PASEO_AGENT_ID",
+] as const;
+
+function readEnvIdentity(env: NodeJS.ProcessEnv = process.env): AgentIdentity | null {
+  const id = env.PASEO_AGENT_ID || env.AGENT_ID || undefined;
+  const name = env.AGENT_NAME || undefined;
+  const model = env.AGENT_MODEL || undefined;
+  const provider = env.AGENT_PROVIDER || undefined;
+  if (!id && !name && !model && !provider) return null;
+  return { id, name, model, provider };
+}
+
+function normalizeEnvelopeJson(raw: unknown): AgentIdentity | null {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw as Record<string, unknown>;
+  const str = (v: unknown): string | undefined =>
+    typeof v === "string" && v.length > 0 ? v : undefined;
+  const identity: AgentIdentity = {
+    id: str(o.id) ?? str(o.agentId),
+    name: str(o.name) ?? str(o.agentName),
+    model: str(o.model),
+    provider: str(o.provider),
+    repo: str(o.repo) ?? str(o.workspace),
+    branch: str(o.branch),
+    envelopeText: str(o.envelopeText) ?? str(o.envelope),
+  };
+  if (!identity.id && !identity.name && !identity.model && !identity.provider && !identity.repo && !identity.branch) return null;
+  return identity;
+}
+
+export async function getAgentIdentity(
+  options: AgentIdentityOptions = {},
+): Promise<AgentIdentity | null> {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const command = options.envelopeCommand ?? "xpufx-tool envelope --format json";
+  const envIdentity = readEnvIdentity();
+  void ENV_KEYS;
+  try {
+    const result = await safeExec(command, { timeoutMs });
+    if (result.code !== 0) return envIdentity;
+    const text = result.stdout.trim();
+    if (!text) return envIdentity;
+    try {
+      const parsed: unknown = JSON.parse(text);
+      const cliIdentity = normalizeEnvelopeJson(parsed);
+      if (!cliIdentity) return envIdentity;
+      if (!envIdentity) return cliIdentity;
+      return {
+        id: envIdentity.id ?? cliIdentity.id,
+        name: envIdentity.name ?? cliIdentity.name,
+        model: envIdentity.model ?? cliIdentity.model,
+        provider: envIdentity.provider ?? cliIdentity.provider,
+        repo: cliIdentity.repo,
+        branch: cliIdentity.branch,
+        envelopeText: cliIdentity.envelopeText,
+      };
+    } catch {
+      return envIdentity;
+    }
+  } catch {
+    return envIdentity;
+  }
+}