@xpufx/paseo-top 0.4.0 → 0.4.1

package/client/telemetry-copy.ts

@@ -1,4 +1,4 @@
-import { formatUptime } from "paseo-plugin-helper/shared";
+import { formatBytes, formatUptime } from "paseo-plugin-helper/shared";
 import { formatCompactTokens, type TopAgentSnapshot } from "./pill-labels";
 import type { TopTimelineTelemetryData } from "../shared/resources";
 
@@ -55,9 +55,16 @@ export function buildTelemetryCopyText({ data, liveUsage, timeLabel }: Telemetry
   const time = timeLabel ?? data.timestamp;
   if (time) lines.push(time);
 
+  // `turnId` is normally an opaque id, but some providers use the source
+  // issue URL. Keep it as a labeled reference: it is useful context, but it
+  // must never become the whole clipboard payload.
+  if (data.turnId) lines.push(`Reference ${data.turnId}`);
+
   const id = shortAgentId(data.agentId);
   if (id) lines.push(`Agent ${id}`);
 
+  if (data.agentTitle) lines.push(`Title ${data.agentTitle}`);
+
   const model = data.agentModel ?? undefined;
   const provider = data.agentProvider ?? undefined;
   if (model || provider) {
@@ -67,6 +74,13 @@ export function buildTelemetryCopyText({ data, liveUsage, timeLabel }: Telemetry
   if (data.branch) lines.push(`Branch ${data.branch}`);
   if (data.worktree) lines.push(`Worktree ${data.worktree}`);
 
+  // These are the first row of the rendered card body. Keep their labels and
+  // formatting aligned with the card so Copy is a human-readable export of
+  // what the operator sees, rather than just an identifier or URL.
+  lines.push(`CPU ${data.cpuPercent}%`);
+  lines.push(`RAM ${formatBytes(data.memUsedBytes)} (${data.memPercent}%)`);
+  lines.push(`Load ${data.loadAvg1m.toFixed(2)}`);
+
   const totalTokens =
     inputTokens != null || outputTokens != null
       ? (inputTokens ?? 0) + (outputTokens ?? 0)

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

@@ -24,16 +24,23 @@ export interface ClipboardEnvironment {
  * `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.
+ * usable off-DOM (native), where it is the real platform clipboard. The same
+ * applies to any `setStringAsync` whose DOM fallback is that unverified
+ * `execCommand`. In a DOM the checked `execCommand` fallback is preferred to
+ * those unverifiable paths.
  */
 export function clipboardTierOrder(env: ClipboardEnvironment): ClipboardTier[] {
   const tiers: ClipboardTier[] = [];
   if (env.hasNavigatorClipboard) tiers.push("navigator");
   if (env.hasHostCopyText) tiers.push("host");
-  if (env.hasRnSetStringAsync) {
+  // On a DOM both RN-web paths are unverifiable: `setString` reports success
+  // even when its `execCommand` no-ops, and a `setStringAsync` that falls back
+  // to it does the same. Off-DOM they are the real native clipboard, so they
+  // lead there; on a DOM only the checked `execCommand` fallback is honest.
+  const rnDomOk = !env.isDom;
+  if (env.hasRnSetStringAsync && rnDomOk) {
     tiers.push("rnAsync");
-  } else if (env.hasRnClipboard && !env.isDom) {
+  } else if (env.hasRnClipboard && rnDomOk) {
     tiers.push("rnSync");
   }
   tiers.push("execCommand");

package/index.client.tsx

@@ -0,0 +1,71 @@
+import type { PluginClientContext } from "@getpaseo/plugin/client";
+import { useRpc } from "@getpaseo/plugin/client";
+import {
+  Icon,
+  Modal,
+  useToast,
+  ScrollView,
+  FlatList,
+  TextInput as HostTextInput,
+  copyText,
+} from "@getpaseo/plugin/client/react-native";
+import { initClientHelpers } from "paseo-plugin-helper/client";
+import { contributeClient } from "./client/pill";
+import { TopTimelineTelemetryCard } from "./client/telemetry";
+import { TurnCounterPanel } from "./client/turn-panel";
+import {
+  TOP_TIMELINE_KIND,
+  TOP_TIMELINE_VERSION,
+  topTimelineTelemetrySchema,
+} from "./shared/resources";
+
+initClientHelpers({
+  Icon,
+  Modal,
+  useRpc,
+  useToast,
+  copyText,
+  ScrollView,
+  FlatList,
+  TextInput: HostTextInput,
+});
+
+export default function contribute(client: PluginClientContext) {
+  const removeTimelineRenderer = client.addTimelineRenderer({
+    kind: TOP_TIMELINE_KIND,
+    version: TOP_TIMELINE_VERSION,
+    schema: topTimelineTelemetrySchema,
+    Component: TopTimelineTelemetryCard,
+  });
+
+  const cleanupClient = contributeClient(client);
+
+  // Agent-scoped panel: exposes the deterministic turn index for the active
+  // conversation (Turn #N + canonical seq) so a human and the agent resolve the
+  // same reference. See client/turn-counter.ts. Agent panels are opened through
+  // a command-center item, which forwards the active agent's openPanel.
+  const removeTurnPanel = client.addWorkspacePanel({
+    id: "top-turn-counter",
+    title: "Turn Counter",
+    icon: "Repeat",
+    context: "agent",
+    Component: TurnCounterPanel,
+  });
+  const removeTurnCommand = client.addCommandCenterItem({
+    id: "top-turn-counter",
+    title: "Turn Counter",
+    icon: "Repeat",
+    keywords: ["turn", "seq", "counter", "conversation"],
+    context: "agent",
+    onSelect(ctx) {
+      ctx.openPanel("top-turn-counter");
+    },
+  });
+
+  return () => {
+    removeTurnCommand();
+    removeTurnPanel();
+    removeTimelineRenderer();
+    cleanupClient();
+  };
+}

package/index.server.ts

@@ -0,0 +1,290 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { guardRpcHandler } from "paseo-plugin-helper/server";
+import {
+  getSystemResourcesRpc,
+  getCustomPillsRpc,
+  listCustomPillsRpc,
+  runCustomPillModalCommandRpc,
+  topSettingsContract,
+  TOP_TIMELINE_KIND,
+  TOP_TIMELINE_VERSION,
+  type LiveUsage,
+  type SystemResources,
+} from "./shared/resources";
+import {
+  handleGetSystemResources,
+  handleGetCustomPills,
+  handleListCustomPills,
+  handleRunCustomPillModalCommand,
+  handleGetSettings,
+  handleUpdateSettings,
+  handleResetSettings,
+  customPillPoller,
+  collectTurnTelemetry,
+  collectGitDiffStat,
+  countTurns,
+  getLastLiveUsage,
+  isInterruptEcho,
+  isStaleTurnEnd,
+  setLastLiveUsage,
+  log,
+} from "./server/resources";
+import { resolveTimelineCadence, shouldAppendTimelineForTurn } from "./shared/resources";
+
+export default function contribute(server: PluginServerContext) {
+  void customPillPoller.start();
+
+  // Shed load instead of hanging the daemon RPC: saturated or slow handlers
+  // answer from the last good snapshot (system-resources) or fail fast.
+  // WARNs are rate-limited (one per minute per cause): saturation fires once
+  // per poll tick per caller while the modal is open, which flooded the log.
+  let lastSystemResources: SystemResources | null = null;
+  const lastWarnAt = { timeout: 0, saturated: 0 };
+  const WARN_COOLDOWN_MS = 60_000;
+  const guardedSystemResources = guardRpcHandler(
+    async (input: Parameters<typeof handleGetSystemResources>[0]) => {
+      const resources = await handleGetSystemResources(input);
+      lastSystemResources = resources;
+      return resources;
+    },
+    {
+      timeoutMs: 5000,
+      maxInflight: 4,
+      getStale: () => lastSystemResources,
+      onTimeout: ({ timeoutMs }) => {
+        const now = Date.now();
+        if (now - lastWarnAt.timeout < WARN_COOLDOWN_MS) return;
+        lastWarnAt.timeout = now;
+        log.warn("system-resources handler timed out", { timeoutMs });
+      },
+      onSaturated: ({ maxInflight }) => {
+        const now = Date.now();
+        if (now - lastWarnAt.saturated < WARN_COOLDOWN_MS) return;
+        lastWarnAt.saturated = now;
+        log.warn("system-resources handler saturated, serving stale", { maxInflight });
+      },
+    },
+  );
+
+  server.handle(topSettingsContract.get, handleGetSettings);
+  server.handle(topSettingsContract.update, handleUpdateSettings);
+  server.handle(topSettingsContract.reset, handleResetSettings);
+  server.handle(getSystemResourcesRpc, guardedSystemResources);
+  server.handle(getCustomPillsRpc, handleGetCustomPills);
+  server.handle(listCustomPillsRpc, handleListCustomPills);
+  server.handle(runCustomPillModalCommandRpc, handleRunCustomPillModalCommand);
+
+  const turnStartTimes = new Map<string, number>();
+  const turnGitBefore = new Map<string, { insertions: number; deletions: number; filesChanged: number }>();
+  // Live turn per agent, set on turn_started and consumed by its terminal, used
+  // to drop terminals that cannot belong to it (see isStaleTurnEnd).
+  const activeTurnIds = new Map<string, string | null>();
+  // Time and timeline user_message count of the last canceled terminal, used to
+  // drop the daemon's extra interrupt terminal (see isInterruptEcho).
+  const lastCanceledAt = new Map<string, number>();
+  const lastCanceledUserMessages = new Map<string, number>();
+  // Per-agent turn counter for the timeline cadence option (0 = never,
+  // 1 = every turn, N>1 = every Nth turn). Counts deduped turn_ended events.
+  const turnCounters = new Map<string, number>();
+
+  const unsubscribeTurnStarted = server.on("agent.turn_started", (event, context) => {
+    turnStartTimes.set(event.agent.id, Date.now());
+    activeTurnIds.set(event.agent.id, event.turnId ?? null);
+    if ((event.agent as any)?.lastUsage) {
+      setLastLiveUsage((event.agent as any).lastUsage);
+    }
+    void context.paseo.agents
+      .ref(event.agent.id)
+      .refresh()
+      .then((refetched) => {
+        if (refetched && (refetched.agent as any)?.lastUsage) {
+          setLastLiveUsage((refetched.agent as any).lastUsage);
+        }
+      })
+      .catch(() => {});
+    void collectGitDiffStat(event.agent.cwd).then(
+      (before) => {
+        if (before) {
+          turnGitBefore.set(event.agent.id, before);
+        } else {
+          turnGitBefore.delete(event.agent.id);
+        }
+      },
+      () => {
+        turnGitBefore.delete(event.agent.id);
+      },
+    );
+  });
+
+  const unsubscribeAgentCreated = server.on("agent.created", (event) => {
+    if ((event.agent as any)?.lastUsage) {
+      setLastLiveUsage((event.agent as any).lastUsage);
+    }
+  });
+
+  async function appendTurnCard(
+    event: any,
+    context: any,
+    startTime: number | undefined,
+    gitBefore: { insertions: number; deletions: number; filesChanged: number } | undefined,
+    turnIndex: number,
+  ): Promise<void> {
+    try {
+      const settings = await handleGetSettings();
+      const cadence = resolveTimelineCadence(settings);
+      if (!shouldAppendTimelineForTurn(cadence, turnIndex)) {
+        return;
+      }
+      const durationMs = startTime ? Date.now() - startTime : undefined;
+
+      let agentModel: string | null = null;
+      let agentProvider: string | null = event.agent.provider ?? null;
+      let agentTitle: string | null = event.agent.title ?? null;
+      try {
+        const refetched = await context.paseo.agents.ref(event.agent.id).refresh();
+        agentModel = refetched?.agent?.model ?? agentModel;
+        agentProvider = refetched?.agent?.provider ?? agentProvider;
+        agentTitle = refetched?.agent?.title ?? agentTitle;
+        let liveUsage =
+          (refetched?.agent?.lastUsage as LiveUsage | null | undefined) ??
+          ((event.agent as any)?.lastUsage as LiveUsage | null | undefined) ??
+          null;
+        const lacksTokens =
+          liveUsage?.inputTokens == null &&
+          liveUsage?.outputTokens == null &&
+          (liveUsage as any)?.contextWindowUsedTokens == null;
+        if (lacksTokens) {
+          const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+          await sleep(150);
+          try {
+            const retry1 = await context.paseo.agents.ref(event.agent.id).refresh();
+            liveUsage =
+              (retry1?.agent?.lastUsage as LiveUsage | null | undefined) ?? liveUsage;
+          } catch {}
+          const stillLacks =
+            liveUsage?.inputTokens == null &&
+            liveUsage?.outputTokens == null &&
+            (liveUsage as any)?.contextWindowUsedTokens == null;
+          if (stillLacks) {
+            await sleep(250);
+            try {
+              const retry2 = await context.paseo.agents.ref(event.agent.id).refresh();
+              liveUsage =
+                (retry2?.agent?.lastUsage as LiveUsage | null | undefined) ?? liveUsage;
+            } catch {}
+          }
+        }
+        setLastLiveUsage(liveUsage);
+      } catch {
+        // Model, provider, and title stay at event snapshot values; the card renders placeholders
+      }
+
+      const telemetry = await collectTurnTelemetry(
+        event.turnId,
+        event.agent.id,
+        event.outcome,
+        durationMs,
+        {
+          cwd: event.agent.cwd,
+          provider: agentProvider,
+          title: agentTitle,
+          model: agentModel,
+          timeline: event.timeline,
+          gitBefore: gitBefore ?? null,
+          liveUsage: getLastLiveUsage(),
+        },
+      );
+
+      await context.paseo.agents.ref(event.agent.id).timeline.append({
+        type: "plugin",
+        id: `top-turn-${event.turnId ?? Date.now()}`,
+        kind: TOP_TIMELINE_KIND,
+        version: TOP_TIMELINE_VERSION,
+        data: telemetry,
+      });
+
+      log.info("Appended turn telemetry to timeline", {
+        agentId: event.agent.id,
+        turnId: event.turnId,
+        outcome: event.outcome.kind,
+        durationMs,
+        cpuPercent: telemetry.cpuPercent,
+        memPercent: telemetry.memPercent,
+      });
+    } catch (err) {
+      log.warn("Failed to record turn telemetry", {
+        agentId: event.agent.id,
+        turnId: event.turnId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  const unsubscribeTurnEnded = server.on("agent.turn_ended", (event, context) => {
+    const settingsPromise = handleGetSettings();
+    void settingsPromise.then((settings) => {
+      if (settings.recordTurnTelemetry === false) {
+        turnStartTimes.delete(event.agent.id);
+        turnGitBefore.delete(event.agent.id);
+        activeTurnIds.delete(event.agent.id);
+        lastCanceledAt.delete(event.agent.id);
+        lastCanceledUserMessages.delete(event.agent.id);
+        return;
+      }
+
+      // On interrupt the daemon emits a second terminal for the turn the cancel
+      // already ended. Skip it so the interrupt renders as one card.
+      const activeTurnId = activeTurnIds.get(event.agent.id);
+      const eventTurnId = event.turnId ?? null;
+      const eventUserMessages = countTurns(event.timeline) ?? 0;
+      const duplicate =
+        isStaleTurnEnd(activeTurnId, eventTurnId) ||
+        isInterruptEcho({
+          lastCanceledAt: lastCanceledAt.get(event.agent.id) ?? null,
+          lastCanceledUserMessages: lastCanceledUserMessages.get(event.agent.id) ?? null,
+          eventUserMessages,
+          now: Date.now(),
+        });
+      if (duplicate) {
+        log.info("Skipped duplicate turn-end telemetry", {
+          agentId: event.agent.id,
+          turnId: event.turnId,
+          activeTurnId: activeTurnId ?? null,
+        });
+        return;
+      }
+      activeTurnIds.delete(event.agent.id);
+      if (event.outcome.kind === "canceled") {
+        lastCanceledAt.set(event.agent.id, Date.now());
+        lastCanceledUserMessages.set(event.agent.id, eventUserMessages);
+      } else {
+        lastCanceledAt.delete(event.agent.id);
+        lastCanceledUserMessages.delete(event.agent.id);
+      }
+
+      const startTime = turnStartTimes.get(event.agent.id);
+      turnStartTimes.delete(event.agent.id);
+      const gitBefore = turnGitBefore.get(event.agent.id);
+      turnGitBefore.delete(event.agent.id);
+      const turnIndex = (turnCounters.get(event.agent.id) ?? 0) + 1;
+      turnCounters.set(event.agent.id, turnIndex);
+      void appendTurnCard(event, context, startTime, gitBefore, turnIndex);
+    }).catch((err) => {
+      log.warn("Failed to record turn telemetry", {
+        agentId: event.agent.id,
+        turnId: event.turnId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    });
+  });
+
+  return () => {
+    activeTurnIds.clear();
+    lastCanceledAt.clear();
+    lastCanceledUserMessages.clear();
+    customPillPoller.stop();
+    unsubscribeTurnStarted();
+    unsubscribeAgentCreated();
+    unsubscribeTurnEnded();
+  };
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@xpufx/paseo-top",
   "private": false,
   "license": "MIT",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "scripts": {
     "stamp": "node -e \"import('./server/vendor/paseo-plugin-helper/version.ts').then(m => m.stampVersion({ targetFile: 'shared/version.ts' }))\"",
     "typecheck": "tsc --noEmit",
@@ -21,6 +21,8 @@
     "paseo-plugin.json",
     "README.md",
     "LICENSE",
+    "index.client.tsx",
+    "index.server.ts",
     "client",
     "server",
     "shared",