@xpufx/paseo-plugin-updates 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # plugin-updates
 
-Git-source update monitor and updater for [Paseo](https://github.com/getpaseo/paseo) plugins (v0.8+).
+Read-only Git-source update monitor for [Paseo](https://github.com/getpaseo/paseo) plugins (v0.8+).
 
 <table align="center">
   <tr>
@@ -9,13 +9,13 @@ Git-source update monitor and updater for [Paseo](https://github.com/getpaseo/pa
   </tr>
 </table>
 
-Adds a header button to every workspace that opens a popover listing the installed plugins. Each row reports whether the plugin's installed git source is current, behind, pinned, missing, or has no upstream, and offers a one-click update when a pullable change exists.
+Adds a header button to every workspace that opens a popover listing the installed plugins. Each row reports whether the plugin's installed git source is current, behind, pinned, missing, or has no upstream.
 
 Built on [paseo-plugin-helper](https://github.com/xpufx/paseo/tree/main/packages/paseo-plugin-helper), the shared Paseo plugin runtime.
 
 > [!NOTE]
 > **Prerequisites & Platform Support**:
-> - The system `git` CLI must be available, because update checks and pulls shell out to `git`.
+> - The system `git` CLI must be available, because update checks shell out to `git`.
 > - Developed and tested primarily on **Linux**.
 
 ## Core Capabilities
@@ -45,12 +45,11 @@ Each row resolves the plugin to its git repository root, ref, and subdirectory,
 - GitHub, GitLab, and unknown forges get an appropriate glyph, and links deep-link into the subdirectory for GitHub (`/tree/<ref>/<subdir>`) and Forgejo/Gitea-style (`/src/branch/<ref>/<subdir>`) hosts.
 - A `dirty` badge appears on a directory install when the plugin scope has uncommitted changes.
 
-### 5. Update Action
-- Available updates show an **Update** button in the row. After a failed pull that needs an override, the button becomes **Force update**.
-- **git-managed installs** delegate to `paseo plugin update <id>`.
-- **directory (path-linked) installs** resolve the repository root and run a fast-forward `git pull`. The pull is refused when the working tree is dirty unless forced, and refused when the local branch has diverged from its upstream.
-- After a successful pull, every plugin that shares the same repository root is reloaded.
-- When more than one plugin has an update, an **Update all** button appears. If any failure requires an override, **Force update all** is offered instead.
+### 5. Native lifecycle blocker
+
+The 0.9.0-beta.2 daemon client has native plugin preview/proposal/apply/reload methods, but they are not exposed through the plugin-facing `PaseoApi` returned by `getPaseoClient(serverId)`. The server lifecycle API is limited to agent/workspace events. Consequently this plugin deliberately has no update action for managed Git or npm sources, local directories, or self-update: it never spawns `paseo plugin update`, pulls, or reloads another plugin.
+
+`useHosts()` is not an update lifecycle API. Choosing a configured host could operate on a different daemon than the installation being displayed, so it is never used as a targeting substitute. Use the host's own plugin management UI/CLI to review and apply updates. The Git diagnostics remain available because native source metadata does not expose their per-subdirectory tree/ref comparison.
 
 ### 6. Orphaned Directory Flagging
 - Directories left behind in Paseo's managed plugin location by an uninstalled or failed install are listed in a separate **Orphaned directories** section with a name and path.
@@ -81,9 +80,8 @@ paseo plugin add ./plugins/plugin-updates
 ## Usage & Configuration
 
 - No settings are required. The header button registers automatically in each workspace that has an agent session.
-- Open the button to see installed plugins, their status, and available updates, then use the row **Update** button or **Update all** to pull and reload.
+- Open the button to see installed plugins, their status, and detected remote changes. Review and apply updates in the owning Paseo host.
 - Checks run against the plugin's install remote only, so a fork or mirror installed as the source is what gets compared.
-- Pulls run with `--ff-only`. A dirty working tree or a diverged branch must be reconciled manually before an update can apply.
 
 ## Limitations
 

package/client/updates.tsx

@@ -13,19 +13,17 @@ import {
   KeyValue,
   KeyValueGroup,
   PluginThemeProvider,
-  ProgressBar,
   Row,
   SectionHeader,
   StatusDot,
   usePluginTheme,
-} from "paseo-plugin-helper/client";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useEffect, useState } from "react";
+} from "./vendor/paseo-plugin-helper/index";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
 import { ActivityIndicator, Linking, Text, View } from "react-native";
+import { NATIVE_PLUGIN_UPDATE_BLOCKER } from "../shared/native-lifecycle";
 import {
   pluginUpdatesCheckRpc,
-  pluginUpdatesUpdateAllRpc,
-  pluginUpdatesUpdateRpc,
   resolveSourceRef,
   shortHash,
   type PluginUpdate,
@@ -102,14 +100,8 @@ function hashValue(value: string | null): string | null {
 
 function PluginRow({
   plugin,
-  updating,
-  forceNeeded,
-  onUpdate,
 }: {
   plugin: PluginUpdate;
-  updating: boolean;
-  forceNeeded: boolean;
-  onUpdate: (pluginId: string, force: boolean) => void;
 }) {
   const { colors, typography, padding } = usePluginTheme();
   const detail = fallbackDetail(plugin);
@@ -138,16 +130,6 @@ function PluginRow({
             />
           ) : null}
           {plugin.dirty === true && !isOrphan ? <Badge label="dirty" variant="warning" dot /> : null}
-          {plugin.updateAvailable && !isOrphan ? (
-            <Button
-              label={forceNeeded ? "Force update" : "Update"}
-              variant={forceNeeded ? "primary" : "secondary"}
-              size="sm"
-              loading={updating}
-              disabled={updating}
-              onPress={() => onUpdate(plugin.id, forceNeeded)}
-            />
-          ) : null}
         </Row>
         <Text selectable numberOfLines={detailLines} style={{ color: colors.foregroundMuted, ...typography.caption }}>
           {detail}
@@ -252,103 +234,23 @@ export function PluginUpdatesIcon(props: PluginButtonIconProps) {
   );
 }
 
-interface Failure {
-  pluginId: string;
-  error: string;
-  requiresForce: boolean;
-}
-
 function PluginUpdatesPopoverInner(props: PluginButtonContentProps) {
   const { colors, typography, padding } = usePluginTheme();
   const toast = useToast();
-  const queryClient = useQueryClient();
   const query = usePluginUpdates(props.workspaceId);
-  const update = useRpc(pluginUpdatesUpdateRpc);
-  const updateAll = useRpc(pluginUpdatesUpdateAllRpc);
-  const [activeUpdate, setActiveUpdate] = useState<string | "all" | null>(null);
-  const [progress, setProgress] = useState(0);
-  const [failures, setFailures] = useState<Failure[]>([]);
 
   const plugins = query.data?.plugins ?? [];
   const rows = partitionedRows(plugins);
   const orphanSection = buildOrphanSection(plugins);
   const staleCount = plugins.filter((plugin) => plugin.updateAvailable).length;
-  const forceCount = failures.filter((failure) => failure.requiresForce).length;
-
   const refresh = async () => {
     try {
-      setFailures([]);
       await query.refetch();
     } catch (error) {
       toast.show(error instanceof Error ? error.message : String(error), { variant: "error" });
     }
   };
 
-  const recordFailure = (failure: Failure) => {
-    setFailures((current) => [
-      ...current.filter((item) => item.pluginId !== failure.pluginId),
-      failure,
-    ]);
-  };
-
-  const clearFailure = (pluginId: string) => {
-    setFailures((current) => current.filter((failure) => failure.pluginId !== pluginId));
-  };
-
-  const runUpdate = async (pluginId: string, force = false) => {
-    setActiveUpdate(pluginId);
-    setProgress(0.25);
-    try {
-      const result = await update({ workspaceId: props.workspaceId, pluginId, force });
-      if (result.status === "error") {
-        recordFailure({
-          pluginId,
-          error: result.error || "Update failed",
-          requiresForce: result.requiresForce === true,
-        });
-        toast.show(result.error || `Failed to update ${pluginId}`, { variant: "error" });
-      } else {
-        clearFailure(pluginId);
-        toast.show(`${pluginId} updated`, { variant: "success" });
-      }
-      setProgress(1);
-      await queryClient.invalidateQueries({ queryKey: [...QUERY_KEY, props.workspaceId] });
-    } catch (error) {
-      toast.show(error instanceof Error ? error.message : String(error), { variant: "error" });
-    } finally {
-      setActiveUpdate(null);
-    }
-  };
-
-  const runUpdateAll = async (force = false) => {
-    setActiveUpdate("all");
-    setProgress(0.1);
-    try {
-      const result = await updateAll({ workspaceId: props.workspaceId, force });
-      const failed = result.results.filter((item) => item.status === "error");
-      setFailures(
-        failed.map((item) => ({
-          pluginId: item.pluginId,
-          error: item.error || "Update failed",
-          requiresForce: item.requiresForce === true,
-        })),
-      );
-      setProgress(1);
-      if (failed.length > 0) {
-        toast.show(`${failed.length} plugin update${failed.length === 1 ? "" : "s"} failed`, {
-          variant: "error",
-        });
-      } else {
-        toast.show("All plugins updated", { variant: "success" });
-      }
-      await queryClient.invalidateQueries({ queryKey: [...QUERY_KEY, props.workspaceId] });
-    } catch (error) {
-      toast.show(error instanceof Error ? error.message : String(error), { variant: "error" });
-    } finally {
-      setActiveUpdate(null);
-    }
-  };
-
   useEffect(() => {
     if (query.isError) {
       toast.show("Unable to check plugin updates", { variant: "error" });
@@ -368,7 +270,10 @@ function PluginUpdatesPopoverInner(props: PluginButtonContentProps) {
           <View style={{ flex: 1 }}>
             <Text style={{ color: colors.foreground, ...typography.heading }}>Plugin updates</Text>
             <Text style={{ color: colors.foregroundMuted, ...typography.caption }}>
-              {query.isFetching ? "Checking installed plugins…" : `${staleCount} update${staleCount === 1 ? "" : "s"} available`}
+              {query.isFetching ? "Checking installed plugins…" : `${staleCount} remote change${staleCount === 1 ? "" : "s"} detected`}
+            </Text>
+            <Text style={{ color: colors.foregroundMuted, ...typography.caption }}>
+              Diagnostics only — {NATIVE_PLUGIN_UPDATE_BLOCKER}
             </Text>
           </View>
           <Button
@@ -376,12 +281,11 @@ function PluginUpdatesPopoverInner(props: PluginButtonContentProps) {
             variant="ghost"
             size="sm"
             loading={query.isFetching}
-            disabled={query.isFetching || activeUpdate !== null}
+            disabled={query.isFetching}
             accessibilityLabel="Refresh plugin update check"
             onPress={refresh}
           />
         </Row>
-        {activeUpdate ? <ProgressBar value={progress} autoStatusColor label="Updating plugins" showValueText /> : null}
         {query.isLoading && !query.data ? (
           <View style={{ alignItems: "center", paddingVertical: padding.vertical * 2 }}>
             <ActivityIndicator color={colors.foregroundMuted} />
@@ -394,58 +298,11 @@ function PluginUpdatesPopoverInner(props: PluginButtonContentProps) {
               <PluginRow
                 key={plugin.id}
                 plugin={plugin}
-                updating={activeUpdate === plugin.id}
-                forceNeeded={failures.some((failure) => failure.pluginId === plugin.id && failure.requiresForce)}
-                onUpdate={runUpdate}
               />
             ))}
             {orphanSection ? <OrphanSection section={orphanSection} /> : null}
           </>
         )}
-        {failures.map((failure) => (
-          <Card key={`failure-${failure.pluginId}`} variant="elevated">
-            <View style={{ gap: padding.gap }}>
-              <Row align="center">
-                <StatusDot variant="danger" />
-                <Text style={{ color: colors.statusDanger, ...typography.bodyStrong, flex: 1 }}>
-                  {failure.pluginId} update failed
-                </Text>
-                {failure.requiresForce ? (
-                  <Button
-                    label="Force"
-                    variant="secondary"
-                    size="sm"
-                    loading={activeUpdate === failure.pluginId}
-                    disabled={activeUpdate !== null}
-                    onPress={() => runUpdate(failure.pluginId, true)}
-                  />
-                ) : null}
-              </Row>
-              <Text selectable style={{ color: colors.foregroundMuted, ...typography.caption }}>
-                {failure.error}
-              </Text>
-            </View>
-          </Card>
-        ))}
-        {forceCount > 0 ? (
-          <Button
-            label="Force update all"
-            variant="secondary"
-            icon="AlertTriangle"
-            loading={activeUpdate === "all"}
-            disabled={activeUpdate !== null}
-            onPress={() => runUpdateAll(true)}
-          />
-        ) : staleCount > 1 ? (
-          <Button
-            label={`Update all (${staleCount})`}
-            variant="primary"
-            icon="DownloadCloud"
-            loading={activeUpdate === "all"}
-            disabled={activeUpdate !== null}
-            onPress={() => runUpdateAll(false)}
-          />
-        ) : null}
       </ScrollView>
     </PluginThemeProvider>
   );

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,10 @@
+import type { PluginClientContext } from "@getpaseo/plugin/client";
+import { useRpc } from "@getpaseo/plugin/client";
+import { Icon, Modal, ScrollView, useToast } from "@getpaseo/plugin/client/react-native";
+import { initClientHelpers } from "./client/vendor/paseo-plugin-helper/index";
+import { registerPluginUpdateHeaders } from "./client/updates";
+
+export default function contribute(client: PluginClientContext) {
+  initClientHelpers({ Icon, Modal, useRpc, ScrollView, useToast });
+  return registerPluginUpdateHeaders(client);
+}

package/index.server.ts

@@ -0,0 +1,8 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { pluginUpdatesCheckRpc } from "./shared/updates";
+import { checkInstalledPlugins } from "./server/updates";
+
+export default function contribute(server: PluginServerContext) {
+  server.handle(pluginUpdatesCheckRpc, ({ workspaceId }) => checkInstalledPlugins(workspaceId));
+  return () => {};
+}

package/package.json

@@ -2,11 +2,11 @@
   "name": "@xpufx/paseo-plugin-updates",
   "private": false,
   "license": "MIT",
-  "version": "0.1.0",
-  "description": "Monitor installed Paseo plugins for git-source updates, with per-subdirectory status, source links, and one-click pulls.",
+  "version": "0.1.2",
+  "description": "Read-only monitor for installed Paseo plugin source status, links, and per-subdirectory Git diagnostics.",
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test": "npm run typecheck && npx tsx --test shared/updates.test.ts server/updates.test.ts client/orphans.test.ts",
+    "test": "npm run typecheck && npx tsx --test shared/updates.test.ts shared/native-lifecycle.test.ts server/updates.test.ts client/orphans.test.ts",
     "test:vitest": "npm run typecheck && vitest run --config vitest.config.ts"
   },
   "devDependencies": {
@@ -22,6 +22,8 @@
     "paseo-plugin.json",
     "README.md",
     "LICENSE",
+    "index.client.tsx",
+    "index.server.ts",
     "client",
     "server",
     "shared",

package/server/updates.ts

@@ -2,31 +2,16 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { listPlugins, safeSpawn, type PaseoPluginInfo, type SafeSpawnResult } from "paseo-plugin-helper/server";
+import { listPlugins, safeSpawn, type PaseoPluginInfo, type SafeSpawnResult } from "./vendor/paseo-plugin-helper/index";
 import { deriveSourceUrl, shortHash } from "../shared/updates";
 import type {
   PluginUpdate,
-  PluginUpdateActionResult,
   PluginUpdateChange,
   RefKind,
 } from "../shared/updates";
 
 const PROBE_TIMEOUT_MS = 10_000;
 const FETCH_TIMEOUT_MS = 30_000;
-const UPDATE_TIMEOUT_MS = 120_000;
-const RELOAD_TIMEOUT_MS = 60_000;
-
-// This plugin's own install id. Paseo runs plugin backend code in the plugin's
-// subprocess, so `paseo plugin reload plugin-updates` terminates the very
-// process executing the update loop (#210). We therefore never reload ourselves
-// from inside ourselves.
-const SELF_PLUGIN_ID = "plugin-updates";
-
-// Shown when the updater updated itself: the pull succeeded, but applying it
-// requires a reload that only the host can safely perform.
-const SELF_UPDATE_DETAIL =
-  "Updated in place. Reload plugin-updates from Settings to apply (a plugin cannot safely reload itself).";
-
 // Report-only verdict for an install whose tracked ref or plugin subdirectory is gone.
 const MISSING_SOURCE_DETAIL = "Plugin does not exist at the source it was installed from.";
 
@@ -1008,325 +993,16 @@ async function scanOrphanedDirs(
   return rows;
 }
 
-// ---------------------------------------------------------------------------
-// Actions
-// ---------------------------------------------------------------------------
-
-function actionResult(
-  pluginId: string,
-  status: "updated" | "error",
-  error: string | null = null,
-  output: string | null = null,
-  requiresForce = false,
-): PluginUpdateActionResult {
-  return {
-    pluginId,
-    status,
-    output: output ?? null,
-    error: error ?? null,
-    ...(requiresForce ? { requiresForce: true } : {}),
-  };
-}
-
-async function invokePaseoUpdate(
-  args: string[],
-  runner: CommandRunner,
-): Promise<{ status: "updated" | "error"; output: string | null; error: string | null }> {
-  try {
-    const result = await runner("paseo", ["plugin", "update", ...args], {
-      timeoutMs: UPDATE_TIMEOUT_MS,
-    });
-    const output = outputOf(result) || null;
-    if (result.code === 0) return { status: "updated", output, error: null };
-    return { status: "error", output, error: output || `paseo plugin update exited with code ${result.code}` };
-  } catch (error) {
-    return { status: "error", output: null, error: errorOf(error) };
-  }
-}
-
-async function reloadPlugin(
-  pluginId: string,
-  runner: CommandRunner,
-): Promise<{ ok: boolean; output: string | null; error: string | null }> {
-  try {
-    const result = await runner("paseo", ["plugin", "reload", pluginId], {
-      timeoutMs: RELOAD_TIMEOUT_MS,
-    });
-    const output = outputOf(result) || null;
-    if (result.code === 0) return { ok: true, output, error: null };
-    return { ok: false, output, error: output || `paseo plugin reload exited with code ${result.code}` };
-  } catch (error) {
-    return { ok: false, output: null, error: errorOf(error) };
-  }
-}
-
-/**
- * Splits the plugins affected by a pull into those we may reload and the ones
- * we must not.
- *
- * `plugin-updates` MUST never reload itself: its handlers run inside the plugin
- * subprocess, so `paseo plugin reload plugin-updates` kills the process that is
- * mid-update — the crash/loop in #210. Callers report the self entry as updated
- * with a "reload from Settings" note instead.
- */
-export function planReloads(
-  ids: string[],
-  selfId: string = SELF_PLUGIN_ID,
-): { reload: string[]; skippedSelf: string[] } {
-  const reload: string[] = [];
-  const skippedSelf: string[] = [];
-  const seen = new Set<string>();
-  for (const id of ids) {
-    if (seen.has(id)) continue;
-    seen.add(id);
-    if (id === selfId) skippedSelf.push(id);
-    else reload.push(id);
-  }
-  return { reload, skippedSelf };
-}
-
-/**
- * Reloads plugins strictly one at a time.
- *
- * Reloads are serialized because each `paseo plugin reload` restarts a plugin
- * subprocess; overlapping them races the daemon's plugin registry (#210).
- */
-async function reloadSerially(
-  ids: string[],
-  runner: CommandRunner,
-): Promise<Array<{ id: string; ok: boolean; output: string | null; error: string | null }>> {
-  const outcomes: Array<{ id: string; ok: boolean; output: string | null; error: string | null }> = [];
-  for (const id of ids) {
-    const reload = await reloadPlugin(id, runner);
-    outcomes.push({ id, ...reload });
-  }
-  return outcomes;
-}
-
-interface PullOutcome {
-  ok: boolean;
-  requiresForce: boolean;
-  output: string | null;
-  error: string | null;
-}
-
-async function checkDirty(root: string, runner: CommandRunner): Promise<boolean | null> {
-  const statusResult = await git(runner, ["status", "--porcelain"], root);
-  if (statusResult.code !== 0) return null;
-  return statusResult.stdout.trim().length > 0;
-}
-
-async function pullRoot(root: string, force: boolean, runner: CommandRunner): Promise<PullOutcome> {
-  const dirty = await checkDirty(root, runner);
-  if (dirty === null) {
-    return { ok: false, requiresForce: false, output: null, error: "git status failed for the plugin repository" };
-  }
-  if (dirty && !force) {
-    return {
-      ok: false,
-      requiresForce: true,
-      output: null,
-      error: "Working tree is dirty — refusing to pull. Re-run with force to override.",
-    };
-  }
-
-  const head = parseCommit((await git(runner, ["rev-parse", "HEAD"], root)).stdout);
-  const upstream = await git(runner, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root);
-  const upstreamName = upstream.code === 0 ? upstream.stdout.trim() : "";
-  if (head && upstreamName && upstreamName !== "HEAD") {
-    const upstreamCommit = parseCommit((await git(runner, ["rev-parse", upstreamName], root)).stdout);
-    if (upstreamCommit) {
-      const remoteBehind = await isAncestor(runner, root, upstreamCommit, head);
-      const localBehind = await isAncestor(runner, root, head, upstreamCommit);
-      if (remoteBehind === false && localBehind === false) {
-        return {
-          ok: false,
-          requiresForce: false,
-          output: null,
-          error: `Branch has diverged from ${upstreamName} — refusing to pull. Reconcile manually.`,
-        };
-      }
-    }
-  }
-
-  const pull = await git(runner, ["pull", "--ff-only"], root, UPDATE_TIMEOUT_MS);
-  const output = outputOf(pull) || null;
-  if (pull.code !== 0) {
-    return { ok: false, requiresForce: false, output, error: output || `git pull --ff-only exited with code ${pull.code}` };
-  }
-  return { ok: true, requiresForce: false, output, error: null };
-}
-
-async function idsSharingRoot(
-  installed: PaseoPluginInfo[],
-  records: Map<string, ManagedRecord>,
-  root: string,
-  runner: CommandRunner,
-): Promise<string[]> {
-  const resolved = await Promise.all(
-    installed.map(async (plugin) => ({
-      id: plugin.id,
-      root: plugin.path ? (await resolveIdentity(plugin, records.get(plugin.id) ?? null, runner)).repoRoot : null,
-    })),
-  );
-  return resolved.filter((entry) => entry.root === root).map((entry) => entry.id);
-}
-
-export interface UpdateOptions {
-  force?: boolean;
-  runner?: CommandRunner;
-  installedOverride?: PaseoPluginInfo[];
-  deps?: ProbeDeps;
-}
-
-export async function updatePlugin(
-  pluginId: string,
-  _workspaceId?: string,
-  options: UpdateOptions = {},
-): Promise<PluginUpdateActionResult> {
-  const runner = options.runner ?? runCommand;
-  const deps = options.deps ?? {};
-  let installed: PaseoPluginInfo[];
-  try {
-    installed = options.installedOverride ?? (await listPlugins({ forceRefresh: true }));
-  } catch (error) {
-    return actionResult(pluginId, "error", `Unable to list installed plugins: ${errorOf(error)}`);
-  }
-  const info = installed.find((plugin) => plugin.id === pluginId);
-  if (!info) return actionResult(pluginId, "error", `Plugin '${pluginId}' is not installed`);
-  if (!info.path) return actionResult(pluginId, "error", `Plugin '${pluginId}' has no directory path`);
-
-  if (info.source === "git") {
-    const result = await invokePaseoUpdate([pluginId], runner);
-    return actionResult(pluginId, result.status, result.error, result.output);
-  }
-
-  const records = await loadManagedRecords(deps);
-  const identity = await resolveIdentity(info, records.get(pluginId) ?? null, runner);
-  if (!identity.repoRoot) {
-    return actionResult(pluginId, "error", `Plugin '${pluginId}' is not a git repository — no git update possible`);
-  }
-  const pull = await pullRoot(identity.repoRoot, options.force ?? false, runner);
-  if (!pull.ok) {
-    return actionResult(pluginId, "error", pull.error, pull.output, pull.requiresForce);
-  }
-
-  const ids = await idsSharingRoot(installed, records, identity.repoRoot, runner);
-  // Never reload ourselves: this handler runs inside the plugin subprocess, so
-  // reloading plugin-updates would kill the process mid-update (#210).
-  const { reload, skippedSelf } = planReloads(ids);
-  const reloadFailures: string[] = [];
-  for (const outcome of await reloadSerially(reload, runner)) {
-    if (!outcome.ok) reloadFailures.push(`${outcome.id}: ${outcome.error}`);
-  }
-  const output = pull.output ?? `Pulled ${identity.repoRoot}`;
-  if (reloadFailures.length > 0) {
-    return actionResult(pluginId, "error", `Pulled but failed to reload: ${reloadFailures.join("; ")}`, output);
-  }
-  // Updating ourselves: the pull succeeded, but only the host can apply it.
-  if (skippedSelf.length > 0) {
-    return actionResult(pluginId, "updated", null, `${output}\n${SELF_UPDATE_DETAIL}`);
-  }
-  return actionResult(pluginId, "updated", null, output);
-}
-
-export async function updateAllPlugins(
-  _workspaceId?: string,
-  options: UpdateOptions = {},
-): Promise<{ results: PluginUpdateActionResult[] }> {
-  const runner = options.runner ?? runCommand;
-  const deps = options.deps ?? {};
-  let installed: PaseoPluginInfo[];
-  try {
-    installed = options.installedOverride ?? (await listPlugins({ forceRefresh: true }));
-  } catch (error) {
-    return {
-      results: [actionResult("all", "error", `Unable to list installed plugins: ${errorOf(error)}`)],
-    };
-  }
-
-  const rows = await probeInstalled(installed, runner, { ...deps, scanOrphans: false });
-  const directoryGroups = new Map<string, PluginUpdate[]>();
-  const gitRows: PluginUpdate[] = [];
-  for (const row of rows) {
-    if (!row.updateAvailable) continue;
-    if (row.source === "git") {
-      gitRows.push(row);
-      continue;
-    }
-    if (!row.repoRoot) continue;
-    const group = directoryGroups.get(row.repoRoot) ?? [];
-    group.push(row);
-    directoryGroups.set(row.repoRoot, group);
-  }
-
-  const results: PluginUpdateActionResult[] = [];
-  for (const row of gitRows) {
-    const result = await invokePaseoUpdate([row.id], runner);
-    results.push(actionResult(row.id, result.status, result.error, result.output));
-  }
-
-  // Phase 1: pull every affected directory root, collecting the outcome. Each
-  // root is pulled exactly once (`directoryGroups` is keyed by root); reloads
-  // are deliberately NOT interleaved here — a reload restarts a plugin
-  // subprocess, and doing that mid-batch is what let a self/shared-root update
-  // tear down the running updater and loop (#210).
-  const pulled = new Map<string, { ids: string[]; pull: PullOutcome }>();
-  for (const [root, group] of directoryGroups) {
-    const ids = group.map((row) => row.id);
-    const pull = await pullRoot(root, options.force ?? false, runner);
-    pulled.set(root, { ids, pull });
-  }
-
-  // Phase 2: reload once, after every pull has completed, strictly serially.
-  for (const [root, { ids, pull }] of pulled) {
-    if (!pull.ok) {
-      for (const id of ids) {
-        results.push(actionResult(id, "error", pull.error, pull.output, pull.requiresForce));
-      }
-      continue;
-    }
-    const { reload, skippedSelf } = planReloads(ids);
-    const outcomes = await reloadSerially(reload, runner);
-    const byId = new Map(outcomes.map((outcome) => [outcome.id, outcome]));
-    for (const id of ids) {
-      if (skippedSelf.includes(id)) {
-        results.push(
-          actionResult(id, "updated", null, `${pull.output ?? `Pulled ${root}`}\n${SELF_UPDATE_DETAIL}`),
-        );
-        continue;
-      }
-      const reload = byId.get(id);
-      results.push(
-        reload?.ok
-          ? actionResult(id, "updated", null, pull.output ?? `Pulled ${root}`)
-          : actionResult(id, "error", reload?.error ?? "reload did not run", pull.output),
-      );
-    }
-  }
-
-  if (results.length === 0) {
-    results.push(actionResult("all", "updated", null, "No plugins with remote updates"));
-  }
-  return { results };
-}
-
 export const testing = {
   probePlugin,
   probeInstalled,
-  pullRoot,
   scanOrphanedDirs,
   checkInstalledPlugins,
-  updatePlugin,
-  updateAllPlugins,
-  planReloads,
   loadManagedRecords,
   resolveIdentity,
   resolveRef,
   classifyBranch,
   classifyTag,
-  SELF_PLUGIN_ID,
   PROBE_TIMEOUT_MS,
   FETCH_TIMEOUT_MS,
-  UPDATE_TIMEOUT_MS,
 };

package/shared/native-lifecycle.ts

@@ -0,0 +1,30 @@
+/**
+ * SDK 0.9.0-beta.2 exposes plugin update methods on DaemonClient, but plugins
+ * receive only PaseoApi through getPaseoClient(serverId). PaseoApi deliberately
+ * omits those methods, so a plugin cannot safely choose a host or mutate an
+ * installation on the daemon's behalf.
+ */
+export const NATIVE_PLUGIN_UPDATE_BLOCKER =
+  "Paseo SDK 0.9.0-beta.2 does not expose plugin update preview/proposal/apply/reload on plugin-facing PaseoApi.";
+
+export type ManagedPluginSource = "git" | "npm" | "directory" | "unknown";
+
+export interface NativePluginUpdateCapability {
+  supported: false;
+  source: ManagedPluginSource;
+  /** No serverId is accepted: selecting another configured host would be unsafe. */
+  hostTarget: null;
+  blocker: typeof NATIVE_PLUGIN_UPDATE_BLOCKER;
+}
+
+/**
+ * Formal, source-independent fallback for every installation kind. Do not turn
+ * useHosts() or getPaseoClient(serverId) into a lifecycle substitute: neither
+ * grants the absent plugin-management API, and a selected server could be the
+ * wrong daemon for this plugin installation.
+ */
+export function nativePluginUpdateCapability(source: string | null | undefined): NativePluginUpdateCapability {
+  const normalized: ManagedPluginSource =
+    source === "git" || source === "npm" || source === "directory" ? source : "unknown";
+  return { supported: false, source: normalized, hostTarget: null, blocker: NATIVE_PLUGIN_UPDATE_BLOCKER };
+}

package/shared/updates.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { defineContract } from "paseo-plugin-helper/shared";
+import { defineContract } from "./vendor/paseo-plugin-helper/index";
 
 export const PluginUpdateStatusSchema = z.enum([
   "checking",
@@ -205,35 +205,3 @@ export const pluginUpdatesCheckRpc = defineContract({
     plugins: z.array(PluginUpdateSchema),
   }),
 });
-
-export const PluginUpdateActionSchema = z.object({
-  pluginId: z.string(),
-  status: z.enum(["updated", "error"]),
-  output: z.string().nullable(),
-  error: z.string().nullable(),
-  requiresForce: z.boolean().optional(),
-});
-export type PluginUpdateActionResult = z.infer<typeof PluginUpdateActionSchema>;
-
-export const pluginUpdatesUpdateRpc = defineContract({
-  name: "plugin-updates.update",
-  description: "Pulls and reloads one installed plugin in place",
-  input: z.object({
-    workspaceId: z.string().optional(),
-    pluginId: z.string(),
-    force: z.boolean().optional(),
-  }),
-  output: PluginUpdateActionSchema,
-});
-
-export const pluginUpdatesUpdateAllRpc = defineContract({
-  name: "plugin-updates.update-all",
-  description: "Pulls and reloads every installed plugin with a remote update",
-  input: z.object({
-    workspaceId: z.string().optional(),
-    force: z.boolean().optional(),
-  }),
-  output: z.object({
-    results: z.array(PluginUpdateActionSchema),
-  }),
-});