paseo-wiki-viewer 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 anh-chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OVERVIEW.md

@@ -0,0 +1,22 @@
+Wiki Viewer opens a Paseo workspace in [wiki-viewer](https://www.npmjs.com/package/wiki-viewer), a local file viewer for markdown, HTML, PDFs, notebooks, office documents, and more.
+
+Search for "Open Wiki Viewer" in the Command Center to open it in the Explorer sidebar, or add the **Wiki Viewer** panel to a workspace. The panel installs or updates wiki-viewer from npm when you press its button; it never downloads anything on its own. On desktop and in the browser the wiki shows inside the panel, with **Open in tab** for a full browser tab. On iOS and Android the panel opens it in your system browser.
+
+On desktop and in the browser, clicking a file path in an agent's chat opens that file in the Wiki Viewer sidebar instead of a Paseo file tab. Alt-click (Option-click) keeps Paseo's file tab. A bare or partial name such as `panel.tsx` opens the most recently modified workspace file whose path ends with it. Links that match no file in the workspace still go to Paseo.
+
+## How it works
+
+The daemon runs wiki-viewer on `127.0.0.1` and puts a small access-checking proxy in front of it. Each open link carries a random grant tied to one workspace directory; the proxy rejects requests without a valid grant and fixes the browsed root to that directory. Because a frame inside Paseo cannot keep cookies, the proxy adds a small script to each viewer page that attaches the grant to the page's own requests. A grant expires after 30 minutes without use.
+
+## Settings
+
+Under Settings, Plugins, Wiki Viewer:
+
+- **Open chat file links in Wiki Viewer**: on by default. Turn it off to leave chat links to Paseo's file tab.
+- **Public URL**: the base URL your devices use to reach the daemon. Empty uses `http://<daemon hostname>:<port>`. Set it when the daemon is reached through another name, a tunnel, or HTTPS.
+- **Port**: the proxy port. 0 picks a free port at each start; pin it if a firewall must allow it.
+- **Viewer root**: run an existing wiki-viewer build or source checkout instead of the managed install in `~/.paseo/wiki-viewer`.
+
+## Limits
+
+The proxy listens on all interfaces of the daemon machine and uses plain HTTP, so anyone on that network who obtains a grant URL can read that workspace until the grant expires. The managed install needs `npm` and `tar` on the daemon's `PATH` and is about 30 MB. Looking up bare file names needs `rg` (ripgrep) on the daemon's `PATH`; the plugin keeps a list of each workspace's files in memory, and in a very large workspace the first lookup can take several seconds.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# Wiki Viewer for Paseo
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A [Paseo](https://paseo.sh) plugin that shows a workspace in [wiki-viewer](https://www.npmjs.com/package/wiki-viewer) inside the Explorer sidebar, and opens file paths clicked in agent chat there. See [OVERVIEW.md](OVERVIEW.md) for what it does, its settings, and its limits.
+
+## Install
+
+```bash
+paseo plugin install npm:paseo-wiki-viewer
+```
+
+Or from source:
+
+```bash
+paseo plugin install github:anh-chu/paseo-wiki-viewer
+```
+
+Then open **Wiki Viewer** from the Command Center (Ctrl+K or ⌘K) and press **Install wiki-viewer** once.
+
+Requirements on the daemon machine: Paseo 0.11.2 or newer, `npm` and `tar` for the viewer install, and `rg` (ripgrep) for chat file-name lookup.
+
+## Develop
+
+```bash
+npm install
+npm run typecheck
+npm test
+paseo plugin install "$PWD"
+paseo plugin reload wiki-viewer
+```
+
+The plugin is a port of `dsh-wiki-viewer` from [anh-chu/dsh-plugins](https://github.com/anh-chu/dsh-plugins).
+
+## License
+
+MIT

package/client/open-requests.ts

@@ -0,0 +1,30 @@
+import { useSyncExternalStore } from "react";
+
+export interface OpenRequest {
+  workspaceId: string;
+  path: string;
+  seq: number;
+  at: number;
+}
+
+let latest: OpenRequest | null = null;
+let seq = 0;
+const listeners = new Set<() => void>();
+
+// Chat link clicks land here; the Wiki Viewer panel for that workspace picks them up.
+export function requestOpen(workspaceId: string, path: string) {
+  latest = { workspaceId, path, seq: ++seq, at: Date.now() };
+  for (const listener of listeners) listener();
+}
+
+function subscribe(listener: () => void) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function useOpenRequest(workspaceId: string): OpenRequest | null {
+  const request = useSyncExternalStore(subscribe, () => latest);
+  return request?.workspaceId === workspaceId ? request : null;
+}

package/client/panel.tsx

@@ -0,0 +1,202 @@
+import { openExternalUrl, useRpc, type PluginWorkspacePanelProps } from "@getpaseo/plugin/client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Pressable, ScrollView, Text, View } from "react-native";
+import { describeWikiVersion, prepareWiki, updateWiki } from "../shared/wiki";
+import { useOpenRequest } from "./open-requests";
+import { canEmbed, postOpenFile, WikiFrame } from "./web";
+
+// Grants live 30 minutes after their last use. Refreshing every 10 keeps the
+// URL ready, so a press opens it synchronously (browsers block a new tab
+// opened after an awaited request).
+const PREPARE_INTERVAL_MS = 10 * 60 * 1000;
+// A chat link that opened this panel counts only if it arrived just now.
+const FRESH_REQUEST_MS = 10_000;
+const READY_DELAY_MS = 1500;
+
+function message(error: unknown, fallback: string) {
+  return error instanceof Error ? error.message : fallback;
+}
+
+export function WikiPanel({ theme, layout, workspaceId, navigation }: PluginWorkspacePanelProps) {
+  const queryClient = useQueryClient();
+  const describeVersion = useRpc(describeWikiVersion);
+  const prepare = useRpc(prepareWiki);
+  const update = useRpc(updateWiki);
+
+  const version = useQuery({ queryKey: ["wiki", "version"], queryFn: () => describeVersion({}) });
+  const installed = version.data?.installed != null;
+  const target = useQuery({
+    queryKey: ["wiki", "prepare", workspaceId],
+    queryFn: () => prepare({ workspaceId }),
+    enabled: installed,
+    refetchInterval: PREPARE_INTERVAL_MS,
+    retry: false,
+  });
+  const install = useMutation({
+    mutationFn: () => update({}),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["wiki"] }),
+  });
+
+  const styles = useMemo(
+    () => ({
+      screen: { flex: 1, backgroundColor: theme.colors.surface0 },
+      body: { padding: layout.compact ? 16 : 24, gap: 12 },
+      title: { color: theme.colors.foreground, fontSize: layout.compact ? 18 : 20, fontWeight: "600" as const },
+      muted: { color: theme.colors.foregroundMuted, fontSize: 13 },
+      error: { color: theme.colors.statusDanger, fontSize: 13 },
+      row: { flexDirection: "row" as const, justifyContent: "space-between" as const, gap: 8 },
+      value: { color: theme.colors.foreground, fontSize: 13, fontFamily: "monospace", flexShrink: 1 },
+      actions: { flexDirection: "row" as const, flexWrap: "wrap" as const, gap: 8 },
+      primary: { paddingVertical: 10, paddingHorizontal: 14, borderRadius: 8, backgroundColor: theme.colors.accent },
+      primaryText: { color: theme.colors.accentForeground, fontWeight: "600" as const },
+      secondary: { paddingVertical: 10, paddingHorizontal: 14, borderRadius: 8, borderWidth: 1, borderColor: theme.colors.border, backgroundColor: theme.colors.surface1 },
+      secondaryText: { color: theme.colors.foreground },
+      disabled: { opacity: 0.5 },
+      toolbar: { padding: 6, borderBottomWidth: 1, borderColor: theme.colors.border },
+      small: { paddingVertical: 4, paddingHorizontal: 10, borderRadius: 6, borderWidth: 1, borderColor: theme.colors.border, backgroundColor: theme.colors.surface1 },
+    }),
+    [theme, layout.compact],
+  );
+
+  const info = version.data;
+  const url = target.data?.url;
+  // The frame keeps its first URL: the grant stays alive while the frame uses
+  // it, and swapping in each refreshed URL would reload the page.
+  const [frameUrl, setFrameUrl] = useState<string | undefined>();
+  // The viewer listens for open requests only once it has started, a moment after the frame loads.
+  const [frameReady, setFrameReady] = useState(false);
+  const [pendingPath, setPendingPath] = useState<string | null>(null);
+  const frameRef = useRef<unknown>(null);
+  const request = useOpenRequest(workspaceId);
+  // A chat link that just opened this panel still needs showing; older ones were seen elsewhere.
+  const handledSeq = useRef(request && Date.now() - request.at < FRESH_REQUEST_MS ? request.seq - 1 : (request?.seq ?? 0));
+  const showFrame = (next: string) => {
+    setFrameReady(false);
+    setFrameUrl(next);
+  };
+  useEffect(() => {
+    if (!request || request.seq <= handledSeq.current) return;
+    handledSeq.current = request.seq;
+    if (frameUrl && frameReady) postOpenFile(frameRef.current, frameUrl, request.path);
+    else setPendingPath(request.path);
+  }, [request, frameUrl, frameReady]);
+  useEffect(() => {
+    if (!url) return;
+    if (pendingPath !== null) {
+      // Not loaded yet: start the frame on the requested file instead.
+      const withFile = new URL(url);
+      withFile.searchParams.set("file", pendingPath);
+      setPendingPath(null);
+      showFrame(withFile.toString());
+    } else if (!frameUrl) {
+      showFrame(url);
+    }
+  }, [url, frameUrl, pendingPath]);
+  const openBrowser = navigation?.openBrowser;
+  const open = () => {
+    if (!url) return;
+    if (openBrowser) openBrowser({ url, workspaceId });
+    else void openExternalUrl(url);
+  };
+
+  const installLabel = install.isPending
+    ? "Installing…"
+    : info?.installed == null
+      ? "Install wiki-viewer"
+      : info.latest !== null && info.updateAvailable
+        ? `Update to ${info.latest}`
+        : "Up to date";
+  const canInstall = !install.isPending && info?.managed === true && (info.installed === null || info.updateAvailable);
+
+  if (canEmbed && frameUrl) {
+    return (
+      <View style={styles.screen}>
+        <View style={[styles.actions, styles.toolbar]}>
+          <Pressable accessibilityRole="button" onPress={() => {
+              // A fresh prepare restarts a dead viewer and yields a new grant, so the frame remounts.
+              void target.refetch().then(({ data }) => data && showFrame(data.url));
+            }} style={styles.small}>
+            <Text style={styles.secondaryText}>Reload</Text>
+          </Pressable>
+          <Pressable accessibilityRole="button" onPress={open} style={styles.small}>
+            <Text style={styles.secondaryText}>Open in tab</Text>
+          </Pressable>
+        </View>
+        <WikiFrame key={frameUrl} url={frameUrl} title="Wiki Viewer" frameRef={frameRef} onLoad={() => setTimeout(() => setFrameReady(true), READY_DELAY_MS)} />
+      </View>
+    );
+  }
+
+  return (
+    <ScrollView style={styles.screen} contentContainerStyle={styles.body}>
+      <Text style={styles.title}>Wiki Viewer</Text>
+      <Text style={styles.muted}>Browse this workspace's files in wiki-viewer.</Text>
+
+      {version.isPending ? <Text style={styles.muted}>Checking versions…</Text> : null}
+      {version.error ? <Text style={styles.error}>{message(version.error, "Version check failed.")}</Text> : null}
+
+      {info ? (
+        <View style={{ gap: 4 }}>
+          <View style={styles.row}>
+            <Text style={styles.muted}>Installed</Text>
+            <Text style={styles.value}>{info.installed ?? "not installed"}</Text>
+          </View>
+          <View style={styles.row}>
+            <Text style={styles.muted}>Latest release</Text>
+            <Text style={styles.value}>{info.latest ?? (info.latestError !== "" ? `check failed (${info.latestError})` : "unknown")}</Text>
+          </View>
+          <View style={styles.row}>
+            <Text style={styles.muted}>Location</Text>
+            <Text style={styles.value}>{info.root}</Text>
+          </View>
+          {info.managed ? null : <Text style={styles.muted}>A custom viewer root is set in Settings; update that install manually.</Text>}
+          {info.checkout ? <Text style={styles.muted}>Source checkout without a production build. Build it there first.</Text> : null}
+        </View>
+      ) : null}
+
+      {target.error ? <Text style={styles.error}>{message(target.error, "Wiki Viewer unavailable.")}</Text> : null}
+      {install.error ? <Text style={styles.error}>{message(install.error, "Install failed.")}</Text> : null}
+      {install.data ? (
+        <Text style={styles.muted}>
+          {install.data.updated ? `Installed wiki-viewer ${install.data.version}.` : `Already on the latest release (${install.data.version ?? "unknown"}).`}
+        </Text>
+      ) : null}
+
+      <View style={styles.actions}>
+        {installed ? (
+          <Pressable
+            accessibilityRole="button"
+            accessibilityLabel="Open the workspace in Wiki Viewer"
+            disabled={!url}
+            onPress={open}
+            style={[styles.primary, !url && styles.disabled]}
+          >
+            <Text style={styles.primaryText}>{target.isPending ? "Starting Wiki Viewer…" : "Open wiki"}</Text>
+          </Pressable>
+        ) : null}
+        {target.error ? (
+          <Pressable accessibilityRole="button" onPress={() => void target.refetch()} style={styles.secondary}>
+            <Text style={styles.secondaryText}>Retry</Text>
+          </Pressable>
+        ) : null}
+        {info ? (
+          <Pressable
+            accessibilityRole="button"
+            disabled={!canInstall}
+            onPress={() => install.mutate()}
+            style={[styles.secondary, !canInstall && styles.disabled]}
+          >
+            <Text style={styles.secondaryText}>{installLabel}</Text>
+          </Pressable>
+        ) : null}
+        {version.error ? (
+          <Pressable accessibilityRole="button" onPress={() => void version.refetch()} style={styles.secondary}>
+            <Text style={styles.secondaryText}>Retry</Text>
+          </Pressable>
+        ) : null}
+      </View>
+      {url && !openBrowser ? <Text style={styles.muted}>Opens in your browser. The link reaches the daemon machine over the network.</Text> : null}
+    </ScrollView>
+  );
+}

package/client/settings.tsx

@@ -0,0 +1,75 @@
+import { useSettings } from "@getpaseo/plugin/client";
+import { SettingsAction, SettingsCard, SettingsInput, SettingsSection, SettingsSwitch } from "@getpaseo/plugin/client/ui";
+import { useState } from "react";
+import { Text } from "react-native";
+import type { PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { wikiSettings } from "../shared/wiki";
+
+export function WikiSettings({ theme }: PluginSurfaceProps) {
+  const settings = useSettings(wikiSettings);
+  if (settings.status !== "ready") {
+    const text = settings.status === "loading" ? "Loading…" : String(settings.error);
+    return <Text style={{ color: theme.colors.foregroundMuted }}>{text}</Text>;
+  }
+  return <Editor key={settings.revision} settings={settings} />;
+}
+
+type ReadySettings = Extract<ReturnType<typeof useSettings<typeof wikiSettings.schema>>, { status: "ready" }>;
+
+function Editor({ settings }: { settings: ReadySettings }) {
+  const [publicUrl, setPublicUrl] = useState(settings.values.publicUrl);
+  const [port, setPort] = useState(String(settings.values.port));
+  const [viewerRoot, setViewerRoot] = useState(settings.values.viewerRoot);
+  const portValue = Number(port);
+  const portError = Number.isInteger(portValue) && portValue >= 0 && portValue <= 65535 ? undefined : "Enter 0 to 65535.";
+  const urlError = publicUrl === "" || /^https?:\/\/\S+$/.test(publicUrl) ? undefined : "Enter an http(s) URL.";
+
+  return (
+    <>
+      <SettingsSection title="Chat">
+        <SettingsCard>
+          <SettingsSwitch
+            label="Open chat file links in Wiki Viewer"
+            hint="Clicking a file path in an agent's chat shows it in the sidebar. Alt-click always opens Paseo's file tab."
+            value={settings.values.openChatLinks}
+            disabled={settings.saving}
+            onValueChange={(openChatLinks) => void settings.save({ ...settings.values, openChatLinks }, settings.revision)}
+          />
+        </SettingsCard>
+      </SettingsSection>
+      <SettingsSection title="Connection">
+        <SettingsCard>
+          <SettingsInput
+            label="Public URL"
+            hint="Base URL your devices use to reach the daemon, for example http://devvm:7791. Empty uses http://<daemon hostname>:<port>."
+            initialValue={publicUrl}
+            placeholder="http://hostname:port"
+            error={urlError}
+            onChangeText={setPublicUrl}
+          />
+          <SettingsInput
+            label="Port"
+            hint="Port of the access-checking proxy on the daemon machine. 0 picks a free port each start."
+            initialValue={port}
+            error={portError}
+            onChangeText={setPort}
+          />
+          <SettingsInput
+            label="Viewer root"
+            hint="A built wiki-viewer install or checkout to run. Empty uses the managed install."
+            initialValue={viewerRoot}
+          placeholder="/path/to/wiki-viewer"
+          onChangeText={setViewerRoot}
+        />
+        <SettingsAction
+          label="Save"
+          error={settings.saveError ? String(settings.saveError) : undefined}
+          actionLabel={settings.saving ? "Saving…" : "Save"}
+          disabled={settings.saving || portError !== undefined || urlError !== undefined}
+          onPress={() => void settings.save({ ...settings.values, publicUrl: publicUrl.trim(), port: portValue, viewerRoot: viewerRoot.trim() }, settings.revision)}
+        />
+      </SettingsCard>
+    </SettingsSection>
+    </>
+  );
+}

package/client/web.ts

@@ -0,0 +1,116 @@
+import { createElement, type Ref } from "react";
+import { Platform } from "react-native";
+
+// Plugins get no webview, so the Explorer panel embeds the viewer with a DOM
+// iframe. That exists only on web and Electron; native clients open a browser.
+export const canEmbed = Platform.OS === "web";
+
+// This plugin typechecks without the DOM library. Declare only what this module uses.
+interface WebFrame {
+  readonly contentWindow: { postMessage(message: unknown, targetOrigin: string): void } | null;
+}
+interface WebElement {
+  closest(selector: string): WebAnchor | null;
+  dispatchEvent(event: unknown): boolean;
+}
+interface WebAnchor {
+  getAttribute(name: string): string | null;
+  readonly style: { display: string };
+}
+interface WebMouseEvent {
+  readonly target: WebElement | null;
+  readonly button: number;
+  readonly altKey: boolean;
+  readonly metaKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly shiftKey: boolean;
+  preventDefault(): void;
+  stopImmediatePropagation(): void;
+}
+interface WebGlobal {
+  readonly document: {
+    addEventListener(type: "click" | "mouseover", listener: (event: WebMouseEvent) => void, capture: boolean): void;
+    removeEventListener(type: "click" | "mouseover", listener: (event: WebMouseEvent) => void, capture: boolean): void;
+  };
+  readonly location: { readonly pathname: string };
+  readonly MouseEvent: new (type: "click", init: { bubbles: boolean; cancelable: boolean }) => unknown;
+}
+
+export function WikiFrame({ url, title, frameRef, onLoad }: { url: string; title: string; frameRef?: Ref<unknown>; onLoad?: () => void }) {
+  if (!canEmbed) return null;
+  const src = new URL(url);
+  src.searchParams.set("embed", "1");
+  src.searchParams.set("chrome", "1");
+  return createElement("iframe", {
+    ref: frameRef,
+    onLoad,
+    src: src.toString(),
+    title,
+    referrerPolicy: "no-referrer",
+    style: { flex: 1, width: "100%", height: "100%", border: 0 },
+  });
+}
+
+// Asks a loaded viewer frame to show a workspace-relative file without reloading.
+export function postOpenFile(frame: unknown, frameUrl: string, path: string) {
+  const win = (frame as WebFrame | null)?.contentWindow;
+  if (!win) return;
+  const url = new URL(frameUrl);
+  win.postMessage({ type: "paseo-wiki-open", grant: url.searchParams.get("grant"), path }, url.origin);
+}
+
+/**
+ * Catches clicks on chat file links before Paseo opens a file tab. On web, Paseo
+ * renders those links as `<a style="display: contents">` around the link text.
+ * `open` resolves to false when the link is not a workspace file; the click is
+ * then replayed so Paseo handles it as usual. Alt-click always goes to Paseo.
+ * Hovering a link calls `prefetch`, as Paseo does, so the click is quick.
+ */
+export function interceptChatFileLinks(handlers: {
+  prefetch(target: string, workspaceId: string): void;
+  open(target: string, workspaceId: string): Promise<boolean>;
+}): () => void {
+  if (Platform.OS !== "web") return () => {};
+  const web = globalThis as unknown as WebGlobal;
+  const fileLinkAt = (element: WebElement | null) => {
+    const anchor = typeof element?.closest === "function" ? element.closest("a[href]") : null;
+    if (!anchor || anchor.style.display !== "contents") return null;
+    const href = anchor.getAttribute("href");
+    if (!href || (/^[a-z][a-z0-9+.-]*:/i.test(href) && !/^file:/i.test(href))) return null;
+    const match = /^\/h\/[^/]+\/workspace\/([^/?#]+)/.exec(web.location.pathname);
+    return match ? { href, workspaceId: decodeURIComponent(match[1]!) } : null;
+  };
+  let replaying = false;
+  const onClick = (event: WebMouseEvent) => {
+    if (replaying || event.button !== 0 || event.altKey || event.metaKey || event.ctrlKey || event.shiftKey) return;
+    const element = event.target;
+    const link = fileLinkAt(element);
+    if (!element || !link) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    const replay = () => {
+      replaying = true;
+      try {
+        element.dispatchEvent(new web.MouseEvent("click", { bubbles: true, cancelable: true }));
+      } finally {
+        replaying = false;
+      }
+    };
+    handlers.open(link.href, link.workspaceId).then(
+      (handled) => {
+        if (!handled) replay();
+      },
+      replay,
+    );
+  };
+  const onHover = (event: WebMouseEvent) => {
+    const link = fileLinkAt(event.target);
+    if (link) handlers.prefetch(link.href, link.workspaceId);
+  };
+  web.document.addEventListener("click", onClick, true);
+  web.document.addEventListener("mouseover", onHover, true);
+  return () => {
+    web.document.removeEventListener("click", onClick, true);
+    web.document.removeEventListener("mouseover", onHover, true);
+  };
+}

package/index.client.tsx

@@ -0,0 +1,54 @@
+import type { PluginClientContext } from "@getpaseo/plugin/client";
+import { WikiPanel } from "./client/panel";
+import { requestOpen } from "./client/open-requests";
+import { WikiSettings } from "./client/settings";
+import { interceptChatFileLinks } from "./client/web";
+import { resolveWikiFile } from "./shared/wiki";
+
+const LOOKUP_TTL_MS = 30_000;
+
+export default function contribute(client: PluginClientContext) {
+  client.addWorkspacePanel({
+    id: "wiki",
+    title: "Wiki Viewer",
+    icon: "BookOpen",
+    context: "workspace",
+    locations: ["workspace", "explorer"],
+    Component: WikiPanel,
+  });
+  client.addCommandCenterItem({
+    id: "open-wiki",
+    title: "Open Wiki Viewer",
+    icon: "BookOpen",
+    keywords: ["wiki", "markdown", "files", "docs"],
+    context: "workspace",
+    onSelect({ openPanel }) {
+      openPanel("wiki", { location: "explorer" });
+    },
+  });
+  client.addSettingsScreen({ id: "viewer", title: "Wiki Viewer", icon: "BookOpen", Component: WikiSettings });
+  // Chat file links open in the Wiki Viewer sidebar instead of a file tab.
+  // Lookups started on hover are reused by the click for a short while.
+  const lookups = new Map<string, { at: number; result: Promise<string | null> }>();
+  const lookup = (target: string, workspaceId: string) => {
+    const key = `${workspaceId}\n${target}`;
+    const cached = lookups.get(key);
+    if (cached && Date.now() - cached.at < LOOKUP_TTL_MS) return cached.result;
+    const result = client.rpc(resolveWikiFile, { workspaceId, target }).then(({ path }) => path);
+    result.catch(() => lookups.delete(key));
+    if (lookups.size > 200) lookups.clear();
+    lookups.set(key, { at: Date.now(), result });
+    return result;
+  };
+  const stopIntercepting = interceptChatFileLinks({
+    prefetch: (target, workspaceId) => void lookup(target, workspaceId).catch(() => {}),
+    async open(target, workspaceId) {
+      const path = await lookup(target, workspaceId);
+      if (!path) return false;
+      requestOpen(workspaceId, path);
+      client.openPanel("wiki", { workspaceId, location: "explorer" });
+      return true;
+    },
+  });
+  return stopIntercepting;
+}

package/index.server.ts

@@ -0,0 +1,32 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { createWikiService, resolveWorkspaceFile, warmFileIndex } from "./server/viewer";
+import { describeWikiVersion, prepareWiki, resolveWikiFile, updateWiki, wikiSettings } from "./shared/wiki";
+
+export default function contribute(server: PluginServerContext) {
+  const settings = server.registerSettings(wikiSettings);
+  const wiki = createWikiService(async () => {
+    const current = await settings.read();
+    if (current.status !== "ready") throw new Error("Wiki Viewer settings are invalid; fix them in Settings");
+    return current.values;
+  });
+
+  server.handle(prepareWiki, async ({ workspaceId }, { paseo }) => {
+    // Resolve the directory on the daemon so a client cannot pick an arbitrary root.
+    const workspace = await paseo.workspaces.ref(workspaceId).refresh();
+    if (!workspace) throw new Error("workspace is unavailable");
+    // Chat links in this workspace resolve against a file list; start building it.
+    warmFileIndex(workspace.workspaceDirectory);
+    return wiki.prepare(workspace.workspaceDirectory);
+  });
+  server.handle(resolveWikiFile, async ({ workspaceId, target }, { paseo }) => {
+    // Off: report no match, so the click goes on to Paseo's file tab.
+    const current = await settings.read();
+    if (current.status === "ready" && !current.values.openChatLinks) return { path: null };
+    const workspace = await paseo.workspaces.ref(workspaceId).refresh();
+    return { path: workspace ? await resolveWorkspaceFile(workspace.workspaceDirectory, target) : null };
+  });
+  server.handle(describeWikiVersion, () => wiki.describeVersion());
+  server.handle(updateWiki, () => wiki.update());
+
+  return () => wiki.dispose();
+}

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "paseo-wiki-viewer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Paseo plugin: browse a workspace in wiki-viewer from the Explorer sidebar, and open chat file links there",
+  "keywords": [
+    "paseo",
+    "paseo-plugin",
+    "wiki",
+    "markdown",
+    "viewer"
+  ],
+  "author": "anh-chu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anh-chu/paseo-wiki-viewer.git"
+  },
+  "homepage": "https://github.com/anh-chu/paseo-wiki-viewer#readme",
+  "bugs": {
+    "url": "https://github.com/anh-chu/paseo-wiki-viewer/issues"
+  },
+  "files": [
+    "paseo-plugin.json",
+    "OVERVIEW.md",
+    "README.md",
+    "LICENSE",
+    "index.client.tsx",
+    "index.server.ts",
+    "client/",
+    "server/",
+    "!server/*.test.ts",
+    "shared/",
+    "assets/"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test server/*.test.ts"
+  },
+  "devDependencies": {
+    "@getpaseo/plugin": "0.11.2",
+    "@tanstack/react-query": "^5.90.11",
+    "@types/node": "^24.19.2",
+    "@types/react": "~19.2.0",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "tsx": "^4.23.15",
+    "typescript": "^5.9.3",
+    "zod": "^4.4.3"
+  }
+}