feat(server,web,mobile): let plugins show statuses on threads

apps/desktop/src/window/DesktopWindow.ts

@@ -34,6 +34,7 @@ import * as ElectronApp from "../electron/ElectronApp.ts";
 import * as DesktopRendererHistory from "../telemetry/DesktopRendererHistory.ts";
 import { makeQuitShortcutHandler } from "./QuitHold.ts";
 import { copyContextMenuImage } from "./ContextMenuImage.ts";
+import { shouldVetoViewFrameNavigation } from "./pluginViewNavigation.ts";
 
 const TITLEBAR_HEIGHT = 40;
 // Matches --workspace-topbar-height in apps/web/src/index.css. Native macOS
@@ -652,6 +653,30 @@ export const make = Effect.gen(function* () {
         void runPromise(electronShell.openExternal(url));
       }
     });
+    // Plugin views may not navigate themselves; see pluginViewNavigation.ts.
+    window.webContents.on("will-frame-navigate", (event) => {
+      if (event.isMainFrame) return;
+      if (
+        !shouldVetoViewFrameNavigation({
+          url: event.url,
+          frame: event.frame,
+          initiator: event.initiator,
+          mainFrame: window.webContents.mainFrame,
+        })
+      )
+        return;
+      event.preventDefault();
+      // Only where it tried to go: a path or query can carry the view's data.
+      const target = URL.parse(event.url);
+      void runPromise(
+        logWindowInfo(
+          "refused a plugin view navigation",
+          target === null
+            ? { protocol: "invalid" }
+            : { protocol: target.protocol, host: target.host },
+        ),
+      );
+    });
 
     // Electron's windowMenu close role owns CmdOrCtrl+W. Holding the
     // close-terminal shortcut can outlive the terminal that handled its first

apps/desktop/src/window/pluginViewNavigation.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { type NavigationFrame, shouldVetoViewFrameNavigation } from "./pluginViewNavigation.ts";
+
+const frame = (
+  frameToken: string,
+  url: string,
+  origin: string,
+  parent: NavigationFrame | null,
+): NavigationFrame => ({ frameToken, url, origin, parent });
+
+const app = frame("app", "t3code-dev://app/", "t3code-dev://app", null);
+const view = frame("view", "about:srcdoc", "null", app);
+const wrapper = frame("wrapper", "about:srcdoc", "null", app);
+const wrappedView = frame("inner", "about:srcdoc", "null", wrapper);
+
+describe("shouldVetoViewFrameNavigation", () => {
+  it("refuses a view navigating itself, including through a policy wrapper", () => {
+    for (const target of [view, wrappedView]) {
+      for (const url of ["about:blank", "http://127.0.0.1:7391/page.html", "data:text/html,x"]) {
+        expect(
+          shouldVetoViewFrameNavigation({ url, frame: target, initiator: target, mainFrame: app }),
+        ).toBe(true);
+      }
+    }
+  });
+
+  it("refuses a navigation with no known initiator", () => {
+    expect(
+      shouldVetoViewFrameNavigation({
+        url: "http://127.0.0.1:7391/redirect",
+        frame: view,
+        initiator: null,
+        mainFrame: app,
+      }),
+    ).toBe(true);
+  });
+
+  it("lets the app mount, wrap and dispose views", () => {
+    const fresh = frame("fresh", "about:blank", "t3code-dev://app", app);
+    expect(
+      shouldVetoViewFrameNavigation({
+        url: "about:srcdoc",
+        frame: fresh,
+        initiator: app,
+        mainFrame: app,
+      }),
+    ).toBe(false);
+    const freshInner = frame("fresh-inner", "about:blank", "null", wrapper);
+    expect(
+      shouldVetoViewFrameNavigation({
+        url: "about:srcdoc",
+        frame: freshInner,
+        initiator: wrapper,
+        mainFrame: app,
+      }),
+    ).toBe(false);
+    expect(
+      shouldVetoViewFrameNavigation({
+        url: "about:blank",
+        frame: view,
+        initiator: app,
+        mainFrame: app,
+      }),
+    ).toBe(false);
+  });
+
+  it("leaves frames outside views alone", () => {
+    const other = frame("other", "https://example.com/", "https://example.com", app);
+    expect(
+      shouldVetoViewFrameNavigation({
+        url: "https://example.com/next",
+        frame: other,
+        initiator: other,
+        mainFrame: app,
+      }),
+    ).toBe(false);
+  });
+});

apps/desktop/src/window/pluginViewNavigation.ts

@@ -0,0 +1,35 @@
+/**
+ * Main-process navigation veto for isolated plugin view frames.
+ *
+ * A plugin view runs in an opaque-origin `about:srcdoc` frame inside a
+ * policy wrapper frame of the same kind. A document's own CSP cannot stop its
+ * frame navigating, so the main process refuses any navigation of a frame in
+ * such a subtree unless the app's main frame started it. Loading
+ * `about:srcdoc` stays allowed so the wrapper can mount its view. Electron
+ * does not report `about:blank` or `data:` here: the wrapper's CSP refuses
+ * `data:`, and the host's ping liveness check ends a view that blanked itself.
+ */
+
+export interface NavigationFrame {
+  readonly url: string;
+  readonly origin: string;
+  readonly frameToken: string;
+  readonly parent: NavigationFrame | null;
+}
+
+const isViewDocument = (frame: NavigationFrame) =>
+  frame.url === "about:srcdoc" && frame.origin === "null";
+
+export function shouldVetoViewFrameNavigation(input: {
+  readonly url: string;
+  readonly frame: NavigationFrame | null;
+  readonly initiator: NavigationFrame | null | undefined;
+  readonly mainFrame: NavigationFrame;
+}): boolean {
+  let insideView = false;
+  for (let frame = input.frame; frame !== null; frame = frame.parent) {
+    if (isViewDocument(frame)) insideView = true;
+  }
+  if (!insideView || input.url === "about:srcdoc") return false;
+  return input.initiator?.frameToken !== input.mainFrame.frameToken;
+}

apps/mobile/src/Stack.tsx

@@ -105,6 +105,10 @@ import {
   SettingsScheduledTaskNewRouteScreen,
   SettingsScheduledTaskEditRouteScreen,
 } from "./features/settings/SettingsScheduledTasksRouteScreen";
+import {
+  SettingsPluginRouteScreen,
+  SettingsPluginsRouteScreen,
+} from "./features/settings/SettingsPluginsRouteScreen";
 import {
   ScheduledTaskModelPickerRouteScreen,
   ScheduledTaskBranchPickerRouteScreen,
@@ -344,6 +348,15 @@ const SettingsContentStack = createV5SheetStackNavigator({
         headerTitleStyle: { fontSize: 16, fontWeight: "800" },
       },
     }),
+    SettingsPlugins: createNativeStackScreen({
+      screen: SettingsPluginsRouteScreen,
+      linking: "plugins",
+      options: { title: "Plugins" },
+    }),
+    SettingsPlugin: createNativeStackScreen({
+      screen: SettingsPluginRouteScreen,
+      options: { title: "Plugin" },
+    }),
     SettingsScheduledTaskNew: createNativeStackScreen({
       screen: SettingsScheduledTaskNewRouteScreen,
       linking: "scheduled-tasks/new",

apps/mobile/src/features/keyboard/CommandPalette.tsx

@@ -1,6 +1,6 @@
 import { useNavigation } from "@react-navigation/native";
 import type { EnvironmentThreadSearchMatch } from "@t3tools/client-runtime/state/thread-search";
-import { THREAD_JUMP_KEYBINDING_COMMANDS } from "@t3tools/contracts";
+import { AuthOrchestrationOperateScope, THREAD_JUMP_KEYBINDING_COMMANDS } from "@t3tools/contracts";
 import { threadPullRequestSearchTerms } from "@t3tools/shared/threadPullRequests";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
@@ -25,13 +25,16 @@ import { cn } from "../../lib/cn";
 import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities";
 import { T3KeyboardCommands } from "../../native/T3KeyboardCommands";
 import { useProjects, useThreadShell, useThreadShells } from "../../state/entities";
+import { runPluginAction, usePluginActions } from "../../state/plugin-actions";
 import { useThreadSearch } from "../../state/queries";
+import { useEnvironmentScope } from "../../state/session";
 import { useWorkspaceEnvironments } from "../../state/workspace";
 import { useSavedRemoteConnections } from "../../state/use-remote-environment-registry";
 import { useAdaptiveWorkspaceLayout } from "../layout/AdaptiveWorkspaceLayout";
 import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider";
 import { ThreadSearchMatchExcerpt } from "../threads/thread-search-match";
 import {
+  buildPluginActionPaletteItems,
   filterCommandPaletteItems,
   nextPaletteIndex,
   type CommandPaletteItem,
@@ -66,6 +69,7 @@ const ACTION_ICONS: Record<string, AppSymbolName> = {
 function itemIcon(item: CommandPaletteItem): AppSymbolName {
   if (item.kind === "project") return "folder";
   if (item.kind === "thread") return "text.bubble";
+  if (item.key.startsWith("plugin-action:")) return "cube";
   return ACTION_ICONS[item.key] ?? "ellipsis";
 }
 
@@ -146,6 +150,17 @@ export function CommandPalette(props: {
   const activeThreadRef = useMemo(() => parseActiveThreadPath(props.pathname), [props.pathname]);
   const activeThread = useThreadShell(activeThreadRef);
   const environments = useWorkspaceEnvironments();
+  // Plugin actions belong to the open thread's environment, else the first connected one.
+  const pluginActionEnvironmentId =
+    activeThreadRef?.environmentId ??
+    environments.find((environment) => environment.connectionState === "connected")
+      ?.environmentId ??
+    null;
+  const pluginActions = usePluginActions(pluginActionEnvironmentId);
+  const canRunPluginActions = useEnvironmentScope(
+    pluginActionEnvironmentId,
+    AuthOrchestrationOperateScope,
+  );
   const { savedConnectionsById } = useSavedRemoteConnections();
   const [query, setQuery] = useState("");
   const [selection, setSelection] = useState<string | null>(null);
@@ -300,6 +315,18 @@ export function CommandPalette(props: {
         })),
       );
     }
+    if (pluginActionEnvironmentId !== null) {
+      actions.push(
+        ...buildPluginActionPaletteItems({
+          actions: pluginActions,
+          canOperate: canRunPluginActions,
+          environmentId: pluginActionEnvironmentId,
+          threadId: activeThread?.id ?? null,
+          projectId: activeThread?.projectId ?? null,
+          runAction: (input) => void runPluginAction(input),
+        }),
+      );
+    }
     const projectItems: CommandPaletteItem[] = projects.map((project) => ({
       key: `project:${scopedProjectKey(project.environmentId, project.id)}`,
       kind: "project",
@@ -346,6 +373,9 @@ export function CommandPalette(props: {
     activeThread,
     activeThreadRef,
     navigation,
+    canRunPluginActions,
+    pluginActionEnvironmentId,
+    pluginActions,
     projects,
     runCommand,
     savedConnectionsById,

apps/mobile/src/features/keyboard/commandPaletteItems.test.ts

@@ -1,6 +1,14 @@
-import { describe, expect, it } from "vite-plus/test";
+import {
+  EnvironmentId,
+  PluginActionId,
+  ProjectId,
+  ThreadId,
+  type PluginAction,
+} from "@t3tools/contracts";
+import { describe, expect, it, vi } from "vite-plus/test";
 
 import {
+  buildPluginActionPaletteItems,
   filterCommandPaletteItems,
   nextPaletteIndex,
   type CommandPaletteItem,
@@ -74,3 +82,79 @@ describe("nextPaletteIndex", () => {
     expect(nextPaletteIndex(0, 1, 0)).toBe(0);
   });
 });
+
+describe("buildPluginActionPaletteItems", () => {
+  const environmentId = EnvironmentId.make("environment-1");
+  const thread = {
+    environmentId,
+    threadId: ThreadId.make("thread-1"),
+    projectId: ProjectId.make("project-1"),
+  };
+  const deploy: PluginAction = {
+    id: PluginActionId.make("installation-1:1:deploy"),
+    pluginId: "acme.deploy",
+    pluginName: "Deploy",
+    name: "deploy",
+    title: "Deploy this branch",
+    target: "thread",
+    placements: ["command-palette"],
+  };
+  const refresh: PluginAction = {
+    ...deploy,
+    id: PluginActionId.make("installation-1:1:refresh"),
+    name: "refresh",
+    title: "Refresh caches",
+    target: "environment",
+  };
+
+  it("runs an offered action in the open thread's environment", () => {
+    const runAction = vi.fn();
+    const offered = buildPluginActionPaletteItems({
+      actions: [deploy],
+      canOperate: true,
+      ...thread,
+      runAction,
+    });
+    expect(offered.map((item) => item.title)).toEqual(["Deploy this branch"]);
+
+    offered[0]?.run();
+
+    expect(runAction).toHaveBeenCalledWith({
+      environmentId: thread.environmentId,
+      action: deploy,
+      target: { _tag: "thread", threadId: thread.threadId },
+    });
+  });
+
+  it("offers environment actions when no thread is open", () => {
+    const runAction = vi.fn();
+    const offered = buildPluginActionPaletteItems({
+      actions: [deploy, refresh],
+      canOperate: true,
+      environmentId,
+      threadId: null,
+      projectId: null,
+      runAction,
+    });
+    expect(offered.map((item) => item.title)).toEqual(["Refresh caches"]);
+
+    offered[0]?.run();
+
+    expect(runAction).toHaveBeenCalledWith({
+      environmentId,
+      action: refresh,
+      target: { _tag: "environment" },
+    });
+  });
+
+  it("offers nothing to a connection that cannot operate the environment", () => {
+    expect(
+      buildPluginActionPaletteItems({
+        actions: [deploy],
+        canOperate: false,
+        ...thread,
+        runAction: vi.fn(),
+      }),
+    ).toEqual([]);
+  });
+});