mulmoclaude 0.1.0

package/src/plugins/wiki/View.vue

@@ -0,0 +1,342 @@
+<template>
+  <div class="h-full bg-white flex flex-col">
+    <!-- Header -->
+    <div class="flex items-center justify-between px-6 py-4 border-b border-gray-100 shrink-0">
+      <div class="flex items-center gap-3">
+        <button v-if="action !== 'index'" class="text-gray-400 hover:text-gray-700" title="Back to index" @click="navigate('index')">
+          <span class="material-icons text-base">arrow_back</span>
+        </button>
+        <h2 class="text-lg font-semibold text-gray-800">{{ title }}</h2>
+      </div>
+      <div class="flex gap-1 items-center">
+        <template v-if="action === 'page' && content">
+          <button
+            class="px-3 py-1 text-xs rounded-full border transition-colors border-gray-200 text-gray-500 hover:bg-gray-50 disabled:opacity-40 w-16 flex items-center justify-center gap-1"
+            :disabled="pdfDownloading"
+            @click="downloadPdf"
+          >
+            <svg v-if="pdfDownloading" class="animate-spin w-3 h-3 shrink-0" viewBox="0 0 24 24" fill="none">
+              <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
+              <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z" />
+            </svg>
+            <span v-else>↓ PDF</span>
+            <span v-if="pdfDownloading">PDF</span>
+          </button>
+          <span v-if="pdfError" class="text-xs text-red-500" :title="pdfError">⚠ PDF failed</span>
+        </template>
+        <button
+          class="px-3 py-1 text-xs rounded-full border transition-colors"
+          :class="action === 'index' ? 'border-blue-400 bg-blue-50 text-blue-700' : 'border-gray-200 text-gray-500 hover:bg-gray-50'"
+          @click="navigate('index')"
+        >
+          Index
+        </button>
+        <button
+          class="px-3 py-1 text-xs rounded-full border transition-colors"
+          :class="action === 'log' ? 'border-blue-400 bg-blue-50 text-blue-700' : 'border-gray-200 text-gray-500 hover:bg-gray-50'"
+          @click="navigate('log')"
+        >
+          Log
+        </button>
+        <button
+          class="px-3 py-1 text-xs rounded-full border transition-colors"
+          :class="action === 'lint_report' ? 'border-blue-400 bg-blue-50 text-blue-700' : 'border-gray-200 text-gray-500 hover:bg-gray-50'"
+          @click="navigate('lint_report')"
+        >
+          Lint
+        </button>
+      </div>
+    </div>
+
+    <!-- Navigation error -->
+    <div v-if="navError" class="mx-6 mt-4 rounded border border-red-200 bg-red-50 px-4 py-2 text-sm text-red-700">
+      {{ navError }}
+    </div>
+
+    <!-- Empty state -->
+    <div v-if="!content && !navError" class="flex-1 flex items-center justify-center text-gray-400 text-sm">
+      <div class="text-center space-y-2">
+        <span class="material-icons text-4xl text-gray-300">menu_book</span>
+        <p>Wiki is empty. Ask the Wiki Manager to ingest a source.</p>
+      </div>
+    </div>
+
+    <!-- Index: page card list -->
+    <div v-else-if="action === 'index' && pageEntries && pageEntries.length > 0" class="flex-1 overflow-y-auto p-4 space-y-2">
+      <div
+        v-for="entry in pageEntries"
+        :key="entry.slug"
+        class="rounded-lg border border-gray-200 p-3 cursor-pointer hover:border-blue-300 hover:bg-blue-50 transition-colors"
+        @click="navigatePage(entry.slug || entry.title)"
+      >
+        <div class="font-medium text-sm text-gray-800">{{ entry.title }}</div>
+        <div v-if="entry.description" class="text-xs text-gray-500 mt-0.5">
+          {{ entry.description }}
+        </div>
+      </div>
+    </div>
+
+    <!-- Markdown content -->
+    <div v-else class="flex-1 overflow-y-auto px-6 py-4 prose prose-sm max-w-none wiki-content" @click="handleContentClick" v-html="renderedContent" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { marked } from "marked";
+import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import type { WikiData, WikiPageEntry } from "./index";
+import { handleExternalLinkClick } from "../../utils/dom/externalLink";
+import { useFreshPluginData } from "../../composables/useFreshPluginData";
+import { renderWikiLinks } from "./helpers";
+import { rewriteMarkdownImageRefs } from "../../utils/image/rewriteMarkdownImageRefs";
+import { apiPost, apiFetchRaw } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+import { errorMessage } from "../../utils/errors";
+
+const props = defineProps<{
+  selectedResult?: ToolResultComplete<WikiData>;
+  sendTextMessage?: (text: string) => void;
+}>();
+const emit = defineEmits<{ updateResult: [result: ToolResultComplete] }>();
+
+const action = ref(props.selectedResult?.data?.action ?? "index");
+const title = ref(props.selectedResult?.data?.title ?? "Wiki");
+const content = ref(props.selectedResult?.data?.content ?? "");
+const pageEntries = ref<WikiPageEntry[]>(props.selectedResult?.data?.pageEntries ?? []);
+
+const { refresh } = useFreshPluginData<WikiData>({
+  // Slug-aware: when the view is currently showing a specific page,
+  // fetch that page by slug; otherwise fetch the index.
+  endpoint: () => {
+    const slug = action.value === "page" ? props.selectedResult?.data?.pageName : undefined;
+    return slug ? `${API_ROUTES.wiki.base}?slug=${encodeURIComponent(slug)}` : API_ROUTES.wiki.base;
+  },
+  extract: (json) => (json as { data?: WikiData }).data ?? null,
+  apply: (data) => {
+    action.value = data.action ?? "index";
+    title.value = data.title ?? "Wiki";
+    content.value = data.content ?? "";
+    pageEntries.value = data.pageEntries ?? [];
+  },
+});
+
+watch(
+  () => props.selectedResult?.uuid,
+  () => {
+    const data = props.selectedResult?.data;
+    if (data) {
+      action.value = data.action ?? "index";
+      title.value = data.title ?? "Wiki";
+      content.value = data.content ?? "";
+      pageEntries.value = data.pageEntries ?? [];
+    }
+    void refresh();
+  },
+);
+
+const renderedContent = computed(() => {
+  if (!content.value) return "";
+  // Rewrite workspace-relative image refs (`![alt](images/foo.png)`)
+  // to `/api/files/raw?path=...` BEFORE marked parses them — without
+  // this, the browser tries to fetch against the SPA route URL
+  // (/chat/…/images/foo.png) and 404s. basePath = wiki/pages for
+  // individual pages so `../images/foo.png` resolves correctly.
+  const basePath = action.value === "page" ? "wiki/pages" : "wiki";
+  const withImages = rewriteMarkdownImageRefs(content.value, basePath);
+  return marked.parse(renderWikiLinks(withImages)) as string;
+});
+
+const navError = ref<string | null>(null);
+const pdfDownloading = ref(false);
+const pdfError = ref<string | null>(null);
+
+async function callApi(body: Record<string, unknown>) {
+  navError.value = null;
+  const response = await apiPost<{
+    data?: {
+      action?: string;
+      title?: string;
+      content?: string;
+      pageEntries?: WikiPageEntry[];
+    };
+  }>(API_ROUTES.wiki.base, body);
+  if (!response.ok) {
+    navError.value = response.status === 0 ? response.error : `Wiki API error ${response.status}: ${response.error}`;
+    return;
+  }
+  const result = response.data;
+  action.value = result.data?.action ?? "index";
+  title.value = result.data?.title ?? "Wiki";
+  content.value = result.data?.content ?? "";
+  pageEntries.value = result.data?.pageEntries ?? [];
+  if (props.selectedResult) {
+    emit("updateResult", {
+      ...props.selectedResult,
+      ...result,
+      toolName: "manageWiki",
+      uuid: props.selectedResult.uuid,
+    });
+  }
+}
+
+function navigate(newAction: string) {
+  callApi({ action: newAction });
+}
+
+function navigatePage(pageName: string) {
+  callApi({ action: "page", pageName });
+}
+
+async function downloadPdf() {
+  pdfError.value = null;
+  pdfDownloading.value = true;
+  let response: Response;
+  try {
+    response = await apiFetchRaw(API_ROUTES.pdf.markdown, {
+      method: "POST",
+      body: JSON.stringify({
+        markdown: content.value,
+        filename: `${title.value}.pdf`,
+      }),
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (err) {
+    pdfError.value = errorMessage(err);
+    pdfDownloading.value = false;
+    return;
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    pdfError.value = `PDF error ${response.status}: ${text}`;
+    pdfDownloading.value = false;
+    return;
+  }
+  const blob = await response.blob();
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = `${title.value}.pdf`;
+  anchor.click();
+  URL.revokeObjectURL(url);
+  pdfDownloading.value = false;
+}
+
+function handleContentClick(event: MouseEvent) {
+  // 1. Internal wiki links: `[[Page Name]]` was rewritten to a
+  //    `<span class="wiki-link">` during markdown pre-processing,
+  //    so it doesn't overlap with regular `<a>` handling.
+  const target = event.target as HTMLElement;
+  const link = target.closest(".wiki-link") as HTMLElement | null;
+  if (link?.dataset.page) {
+    navigatePage(link.dataset.page);
+    return;
+  }
+  // 2. External http(s) links in the rendered markdown body: open
+  //    in a new tab so clicking them doesn't navigate the whole
+  //    SPA away from MulmoClaude. Same-origin and non-http links
+  //    (mailto:, tel:, anchors) fall through to the browser default.
+  handleExternalLinkClick(event);
+}
+</script>
+
+<style scoped>
+.wiki-content :deep(.wiki-link) {
+  color: #2563eb;
+  cursor: pointer;
+  text-decoration: underline;
+  text-decoration-style: dotted;
+}
+.wiki-content :deep(.wiki-link:hover) {
+  text-decoration-style: solid;
+}
+.wiki-content :deep(h1) {
+  font-size: 1.5rem;
+  font-weight: 700;
+  margin-top: 1.5rem;
+  margin-bottom: 0.75rem;
+  color: #111827;
+}
+.wiki-content :deep(h2) {
+  font-size: 1.2rem;
+  font-weight: 600;
+  margin-top: 1.25rem;
+  margin-bottom: 0.5rem;
+  color: #1f2937;
+  border-bottom: 1px solid #e5e7eb;
+  padding-bottom: 0.25rem;
+}
+.wiki-content :deep(h3) {
+  font-size: 1rem;
+  font-weight: 600;
+  margin-top: 1rem;
+  margin-bottom: 0.5rem;
+  color: #374151;
+}
+.wiki-content :deep(p) {
+  margin-bottom: 0.75rem;
+  line-height: 1.6;
+  color: #374151;
+}
+.wiki-content :deep(ul),
+.wiki-content :deep(ol) {
+  margin-left: 1.5rem;
+  margin-bottom: 0.75rem;
+}
+.wiki-content :deep(li) {
+  margin-bottom: 0.25rem;
+  line-height: 1.5;
+  color: #374151;
+}
+.wiki-content :deep(ul) {
+  list-style-type: disc;
+}
+.wiki-content :deep(ol) {
+  list-style-type: decimal;
+}
+.wiki-content :deep(hr) {
+  border: none;
+  border-top: 1px solid #e5e7eb;
+  margin: 1rem 0;
+}
+.wiki-content :deep(code) {
+  background: #f3f4f6;
+  padding: 0.1rem 0.3rem;
+  border-radius: 0.25rem;
+  font-size: 0.85em;
+  font-family: monospace;
+}
+.wiki-content :deep(pre) {
+  background: #f3f4f6;
+  padding: 0.75rem;
+  border-radius: 0.375rem;
+  overflow-x: auto;
+  margin-bottom: 0.75rem;
+}
+.wiki-content :deep(pre code) {
+  background: none;
+  padding: 0;
+}
+.wiki-content :deep(blockquote) {
+  border-left: 3px solid #d1d5db;
+  padding-left: 1rem;
+  color: #6b7280;
+  margin: 0.75rem 0;
+}
+.wiki-content :deep(table) {
+  border-collapse: collapse;
+  width: 100%;
+  margin-bottom: 0.75rem;
+  font-size: 0.875rem;
+}
+.wiki-content :deep(th),
+.wiki-content :deep(td) {
+  border: 1px solid #e5e7eb;
+  padding: 0.5rem 0.75rem;
+  text-align: left;
+}
+.wiki-content :deep(th) {
+  background: #f9fafb;
+  font-weight: 600;
+}
+</style>

package/src/plugins/wiki/definition.ts

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from "gui-chat-protocol";
+
+const toolDefinition: ToolDefinition = {
+  type: "function",
+  name: "manageWiki",
+  description:
+    "Display wiki content in the canvas — the index catalog, a specific page, the activity log, or a lint report. Call this whenever you want to show wiki content to the user.",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["index", "page", "log", "lint_report"],
+        description: "'index' = show the page catalog, 'page' = show a single page, 'log' = show activity log, 'lint_report' = run health check.",
+      },
+      pageName: {
+        type: "string",
+        description: "For 'page' action: the page title or filename slug to display.",
+      },
+    },
+    required: ["action"],
+  },
+};
+
+export default toolDefinition;

package/src/plugins/wiki/helpers.ts

@@ -0,0 +1,59 @@
+// Pure helpers for wiki/View.vue. Replaces the former
+// `/\[\[([^\]]+)\]\]/g` regex — flagged by `sonarjs/slow-regex`
+// for backtracking risk — with a linear walker.
+
+/**
+ * Replace every `[[page name]]` occurrence in `content` with a
+ * `<span class="wiki-link" data-page="…">…</span>` element. The
+ * page name may not contain `]`; an opening `[[` that is not
+ * followed later by `]]` (with no bare `]` in between) is left
+ * untouched so malformed text renders as-is — matching the
+ * previous regex's non-match behaviour.
+ *
+ * The page-name text is used both as the `data-page` attribute
+ * value and as the span's visible text, identical to the old
+ * replacement string `'<span class="wiki-link" data-page="$1">$1</span>'`.
+ */
+export function renderWikiLinks(content: string): string {
+  const out: string[] = [];
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "[" && content[i + 1] === "[") {
+      const closeStart = findNextCloseBrackets(content, i + 2);
+      if (closeStart !== -1) {
+        const page = content.slice(i + 2, closeStart);
+        out.push(`<span class="wiki-link" data-page="${page}">${page}</span>`);
+        i = closeStart + 2;
+        continue;
+      }
+    }
+    out.push(content[i]);
+    i++;
+  }
+  return out.join("");
+}
+
+/**
+ * Starting at `from`, scan forward for a `]]` sequence. Returns
+ * the index of the first `]` of that pair, or -1 if a bare `]`
+ * (one not immediately followed by a second `]`) is encountered
+ * first — mirroring the old regex's `[^\]]+` constraint that the
+ * page name must contain no `]` characters. Also returns -1 if
+ * nothing matched before the end of input, or if the pair sits
+ * immediately after `from` (zero-length page name, which the old
+ * regex rejected via the `+` quantifier).
+ */
+function findNextCloseBrackets(s: string, from: number): number {
+  let j = from;
+  while (j < s.length) {
+    if (s[j] === "]") {
+      if (s[j + 1] === "]" && j > from) return j;
+      // Bare `]` inside the page-name span — old regex would not
+      // match here, so we bail and let the caller emit the `[[`
+      // as literal text.
+      return -1;
+    }
+    j++;
+  }
+  return -1;
+}

package/src/plugins/wiki/index.ts

@@ -0,0 +1,52 @@
+import type { ToolPlugin } from "../../tools/types";
+import type { ToolResult } from "gui-chat-protocol";
+import View from "./View.vue";
+import Preview from "./Preview.vue";
+import toolDefinition from "./definition";
+import { apiPost } from "../../utils/api";
+import { API_ROUTES } from "../../config/apiRoutes";
+
+export interface WikiPageEntry {
+  title: string;
+  slug: string;
+  description: string;
+}
+
+export interface WikiData {
+  action: string;
+  title: string;
+  content: string;
+  pageEntries?: WikiPageEntry[];
+  pageName?: string;
+}
+
+const wikiPlugin: ToolPlugin<WikiData> = {
+  toolDefinition,
+
+  async execute(_context, args) {
+    const result = await apiPost<ToolResult<WikiData>>(API_ROUTES.wiki.base, args);
+    if (!result.ok) {
+      // Return an error ToolResult instead of throwing so execute()
+      // stays symmetric with every other plugin in this repo. Callers
+      // can branch on the `error` field uniformly.
+      const prefix = result.status === 0 ? "Wiki request failed" : `Wiki API error ${result.status}`;
+      return {
+        toolName: "manageWiki",
+        uuid: crypto.randomUUID(),
+        message: `${prefix}: ${result.error}`,
+      };
+    }
+    return {
+      ...result.data,
+      toolName: "manageWiki",
+      uuid: result.data.uuid ?? crypto.randomUUID(),
+    };
+  },
+
+  isEnabled: () => true,
+  generatingMessage: "Loading wiki...",
+  viewComponent: View,
+  previewComponent: Preview,
+};
+
+export default wikiPlugin;

package/src/router/guards.ts

@@ -0,0 +1,61 @@
+// Navigation guard: validates and sanitizes URL parameters.
+//
+// All incoming route params / query values are untrusted — they could
+// come from a user-typed URL, a pasted link, or a malicious redirect.
+// This guard runs before every navigation and rewrites invalid state
+// to safe defaults without the user noticing (router.replace, which
+// doesn't push a history entry).
+
+import type { Router } from "vue-router";
+import { VALID_VIEW_MODES } from "../utils/canvas/viewMode";
+
+// Basic sanity check for a session ID. Real existence verification
+// happens in App.vue's onMounted / loadSession — we can't do async
+// server calls in a synchronous beforeEach guard without making
+// every navigation await a fetch. Instead, reject values that are
+// obviously malicious (HTML tags, extremely long, contain path
+// separators) and let the app-level code handle "valid format but
+// doesn't exist on the server" gracefully.
+const SESSION_ID_RE = /^[\w-]{1,128}$/;
+
+function isValidSessionId(id: unknown): boolean {
+  return typeof id === "string" && SESSION_ID_RE.test(id);
+}
+
+export function installGuards(router: Router): void {
+  router.beforeEach((to) => {
+    // Only run guards on the chat route — other routes (redirect, etc.)
+    // don't carry parameters that need sanitizing.
+    if (to.name !== "chat") return;
+
+    // ── sessionId format check ───────────────────────────────────
+    const sessionId = to.params.sessionId;
+    if (typeof sessionId === "string" && sessionId.length > 0 && !isValidSessionId(sessionId)) {
+      // Garbage sessionId → strip it and go to /chat (new session).
+      return { name: "chat", params: {}, query: {}, replace: true };
+    }
+
+    // ── view mode whitelist ──────────────────────────────────────
+    const view = to.query.view;
+    if (typeof view === "string" && !VALID_VIEW_MODES.has(view)) {
+      const cleaned = { ...to.query };
+      delete cleaned.view;
+      return { ...to, query: cleaned, replace: true };
+    }
+
+    // ── file path traversal check ────────────────────────────────
+    const filePath = to.query.path;
+    if (typeof filePath === "string") {
+      if (filePath.includes("..") || filePath.startsWith("/")) {
+        const cleaned = { ...to.query };
+        delete cleaned.path;
+        return { ...to, query: cleaned, replace: true };
+      }
+
+      // ?path= without ?view=files → auto-add view=files so FilesView mounts.
+      if (view !== "files") {
+        return { ...to, query: { ...to.query, view: "files" }, replace: true };
+      }
+    }
+  });
+}

package/src/router/index.ts

@@ -0,0 +1,50 @@
+// Vue-router setup (history mode — clean URLs without #).
+//
+// The route is /chat/:sessionId? which captures the session the user
+// was looking at. Everything else (view mode, file path, result uuid,
+// role) lives in query parameters and will be wired in later phases.
+//
+// The "/" → "/chat" redirect ensures a fresh browser tab always lands
+// on the chat view with the default (new) session, matching the
+// current pre-router behaviour.
+//
+// History mode requires the server to serve index.html for any path
+// that doesn't match an API route or static file. In production the
+// Express catch-all `app.get("*", ...)` in server/index.ts already
+// does this. In dev, Vite's default SPA fallback handles it.
+
+import { defineComponent, h } from "vue";
+import { createRouter, createWebHistory, type RouteRecordRaw } from "vue-router";
+
+// Stub component that renders nothing. Required by vue-router (every
+// route needs a component) but never actually mounted because App.vue
+// doesn't contain <router-view> in Phase 0.
+const Stub = defineComponent({ render: () => h("div") });
+
+const routes: RouteRecordRaw[] = [
+  {
+    path: "/",
+    redirect: "/chat",
+  },
+  {
+    // sessionId is optional — /chat with no param means "new session"
+    // (the App.vue logic that auto-creates a session continues to
+    // handle this).
+    path: "/chat/:sessionId?",
+    name: "chat",
+    component: Stub,
+  },
+  {
+    // Catch-all: unknown paths redirect to /chat so a stale bookmark
+    // or a typo doesn't show a blank page.
+    path: "/:pathMatch(.*)*",
+    redirect: "/chat",
+  },
+];
+
+const router = createRouter({
+  history: createWebHistory(),
+  routes,
+});
+
+export default router;

package/src/tools/index.ts

@@ -0,0 +1,52 @@
+import type { PluginEntry } from "./types";
+import textResponsePlugin from "../plugins/textResponse/index";
+import markdownPlugin from "../plugins/markdown/index";
+import spreadsheetPlugin from "../plugins/spreadsheet/index";
+import MindMapPlugin from "@gui-chat-plugin/mindmap/vue";
+import generateImagePlugin from "../plugins/generateImage/index";
+import QuizPlugin from "@mulmochat-plugin/quiz/vue";
+import FormPlugin from "@mulmochat-plugin/form/vue";
+import canvasPlugin from "../plugins/canvas/index";
+import editImagePlugin from "../plugins/editImage/index";
+import Present3DPlugin from "@gui-chat-plugin/present3d/vue";
+import WeatherPlugin from "@gui-chat-plugin/weather/vue";
+import todoPlugin from "../plugins/todo/index";
+import schedulerPlugin from "../plugins/scheduler/index";
+import manageRolesPlugin from "../plugins/manageRoles/index";
+import manageSkillsPlugin from "../plugins/manageSkills/index";
+import manageSourcePlugin from "../plugins/manageSource/index";
+import wikiPlugin from "../plugins/wiki/index";
+import presentMulmoScriptPlugin from "../plugins/presentMulmoScript/index";
+import presentHtmlPlugin from "../plugins/presentHtml/index";
+import presentChartPlugin from "../plugins/chart/index";
+
+const plugins: Record<string, PluginEntry> = {
+  "text-response": textResponsePlugin.plugin,
+  manageTodoList: todoPlugin,
+  manageScheduler: schedulerPlugin,
+  manageRoles: manageRolesPlugin,
+  manageSkills: manageSkillsPlugin,
+  manageSource: manageSourcePlugin,
+  manageWiki: wikiPlugin,
+  presentMulmoScript: presentMulmoScriptPlugin,
+  presentDocument: markdownPlugin,
+  presentSpreadsheet: spreadsheetPlugin,
+  createMindMap: MindMapPlugin.plugin,
+  generateImage: generateImagePlugin,
+  putQuestions: QuizPlugin.plugin,
+  presentForm: FormPlugin.plugin,
+  openCanvas: canvasPlugin,
+  presentHtml: presentHtmlPlugin,
+  presentChart: presentChartPlugin,
+  editImage: editImagePlugin,
+  present3D: Present3DPlugin.plugin,
+  weather: WeatherPlugin.plugin,
+};
+
+export function getPlugin(name: string): PluginEntry | null {
+  return plugins[name] ?? null;
+}
+
+export function getAllPluginNames(): string[] {
+  return Object.keys(plugins);
+}

package/src/tools/types.ts

@@ -0,0 +1,27 @@
+import type { ToolPlugin as BaseToolPlugin, InputHandler, ToolContextApp, ToolDefinition } from "gui-chat-protocol/vue";
+import type { Component } from "vue";
+
+/**
+ * Extended app context with file system access for workspace-aware plugins
+ */
+export interface MulmoClaudeToolContextApp extends ToolContextApp {
+  readFile: (path: string) => Promise<string>;
+  writeFile: (path: string, content: string) => Promise<void>;
+  workspacePath: () => string;
+}
+
+/**
+ * MulmoClaude ToolPlugin — no app-specific server response type needed
+ */
+export type ToolPlugin<T = unknown, J = unknown, A extends object = object> = BaseToolPlugin<T, J, A, InputHandler, Record<string, unknown>>;
+
+/**
+ * View-only plugin entry for the frontend registry.
+ * Only the properties actually used on the client side are required.
+ * This avoids contravariance issues with execute's args type parameter.
+ */
+export interface PluginEntry {
+  toolDefinition: ToolDefinition;
+  viewComponent?: Component;
+  previewComponent?: Component;
+}