obsidian-catui-acp 0.1.0

package/src/main.ts

@@ -0,0 +1,529 @@
+import { Notice, Plugin } from "obsidian";
+import type { UIMessageChunk } from "ai";
+import { CatuiAcpClient } from "./acp/catui-client";
+import { CatuiProcess } from "./acp/catui-process";
+import { NdjsonRpcPeer } from "./acp/ndjson-rpc";
+import type { AcpListSessionsResult, AcpPermissionRequestParams, AcpSessionUpdateParams } from "./acp/types";
+import { buildPromptWithVaultContext } from "./context/vault-context";
+import { classifyPermissionRisk, createPermissionOutcome, type PermissionChoice } from "./policy/permission-policy";
+import { CatuiAcpSettingTab, DEFAULT_SETTINGS, splitArgs, type CatuiAcpSettings } from "./settings";
+import { CATUI_ACP_VIEW_TYPE, CatuiAcpView } from "./ui/chat-view";
+
+interface FileSystemAdapterLike {
+  getBasePath(): string;
+}
+
+export interface PluginDiagnostics {
+  pluginVersion: string;
+  obsidianVersion: string;
+  startedAt: string;
+  loadEvents: string[];
+  runtimeErrors: string[];
+  stderrTail: string;
+  stderrTotal: number;
+  activeCommand: string;
+}
+
+const DIAGNOSTICS_BUFFER_LIMIT = 50;
+
+export type CatuiConnectionStatus = "Disconnected" | "Starting" | "Connected";
+
+export interface PendingPermission {
+  title: string;
+  detail: string;
+}
+
+export type CatuiSessionSummary = AcpListSessionsResult["sessions"][number];
+
+type ActiveTurn = {
+  controller: ReadableStreamDefaultController<UIMessageChunk>;
+  textId: string;
+  textStarted: boolean;
+  closed: boolean;
+};
+
+export default class CatuiAcpPlugin extends Plugin {
+  settings: CatuiAcpSettings = DEFAULT_SETTINGS;
+  connectionStatus: CatuiConnectionStatus = "Disconnected";
+  pendingPermission: PendingPermission | null = null;
+  sessions: CatuiSessionSummary[] = [];
+  activeSessionId: string | null = null;
+  private process = new CatuiProcess();
+  private client: CatuiAcpClient | null = null;
+  private activeTurn: ActiveTurn | null = null;
+  private permissionResolver: ((choice: PermissionChoice) => void) | null = null;
+  private readonly closedSessionIds = new Set<string>();
+  private readonly statusListeners = new Set<(status: CatuiConnectionStatus) => void>();
+  private readonly permissionListeners = new Set<(permission: PendingPermission | null) => void>();
+  private readonly sessionListeners = new Set<(state: { activeSessionId: string | null; sessions: CatuiSessionSummary[] }) => void>();
+  private readonly diagnosticsListeners = new Set<(snapshot: PluginDiagnostics) => void>();
+  private readonly loadEvents: string[] = [];
+  private readonly runtimeErrors: string[] = [];
+  private readonly startedAt = new Date().toISOString();
+
+  async onload(): Promise<void> {
+    this.recordLoadEvent("onload:start");
+    this.installGlobalErrorHandlers();
+    try {
+      await this.loadSettings();
+      this.recordLoadEvent("settings:loaded");
+    } catch (error) {
+      this.recordLoadEvent(`settings:error:${String(error)}`);
+      throw error;
+    }
+    this.addSettingTab(new CatuiAcpSettingTab(this.app, this));
+    this.recordLoadEvent("settings:tab-added");
+    this.registerView(CATUI_ACP_VIEW_TYPE, (leaf) => new CatuiAcpView(leaf, this));
+    this.addRibbonIcon("cat", "Open CatUI ACP", () => {
+      void this.activateView();
+    });
+    this.addRibbonIcon("bug", "CatUI ACP: Diagnostics", () => {
+      void this.activateView();
+    });
+    this.addCommand({
+      id: "open-catui-acp",
+      name: "Open CatUI ACP",
+      callback: () => void this.activateView(),
+    });
+    this.register(() => this.process.stop());
+    this.registerDomEvent(window, "beforeunload", () => this.process.stop());
+    this.process.on("stderr", (text) => {
+      this.recordLoadEvent(`process:stderr:${String(text).trim().slice(0, 200)}`);
+      this.enqueueError(String(text).trim());
+    });
+    this.process.on("error", (error) => {
+      this.recordLoadEvent(`process:error:${String(error)}`);
+      this.client = null;
+      this.setConnectionStatus("Disconnected");
+      this.setActiveSessionId(null);
+      this.enqueueError(`CatUI failed to start: ${String(error)}`);
+    });
+    this.process.on("exit", ({ code, signal }) => {
+      this.recordLoadEvent(`process:exit:${code ?? signal ?? "unknown"}`);
+      this.client = null;
+      this.setConnectionStatus("Disconnected");
+      this.setActiveSessionId(null);
+      this.enqueueError(`CatUI exited (${code ?? signal ?? "unknown"}).`);
+    });
+    this.recordLoadEvent("onload:done");
+  }
+
+  onunload(): void {
+    this.process.stop();
+    this.app.workspace.detachLeavesOfType(CATUI_ACP_VIEW_TYPE);
+  }
+
+  async activateView(): Promise<void> {
+    const leaves = this.app.workspace.getLeavesOfType(CATUI_ACP_VIEW_TYPE);
+    const leaf = leaves[0] ?? this.app.workspace.getRightLeaf(false);
+    if (!leaf) {
+      new Notice("Could not open CatUI ACP view.");
+      return;
+    }
+    await leaf.setViewState({ type: CATUI_ACP_VIEW_TYPE, active: true });
+    this.app.workspace.revealLeaf(leaf);
+  }
+
+  async ensureClient(): Promise<void> {
+    if (this.client) return;
+    this.setConnectionStatus("Starting");
+    const cwd = this.getVaultBasePath();
+    const child = this.process.start({
+      command: this.settings.command,
+      args: splitArgs(this.settings.args),
+      cwd,
+    });
+    const peer = new NdjsonRpcPeer(child.stdout, child.stdin);
+    this.client = new CatuiAcpClient(peer, cwd);
+    this.client.on("session-update", (params) => this.handleSessionUpdate(params as AcpSessionUpdateParams));
+    this.client.on("permission-request", (params, resolve) =>
+      this.handlePermissionRequest(params as AcpPermissionRequestParams, resolve as (value: unknown) => void),
+    );
+    this.client.on("error", (error) =>
+      this.enqueueError(`ACP protocol: ${error.message}`),
+    );
+
+    try {
+      await this.client.initialize();
+      const session = await this.client.newSession();
+      this.closedSessionIds.delete(session.sessionId);
+      this.setActiveSessionId(session.sessionId);
+      await this.client.setMode(this.settings.defaultMode);
+      this.setConnectionStatus("Connected");
+      void this.refreshSessions();
+    } catch (error) {
+      this.client = null;
+      this.process.stop();
+      const message = error instanceof Error ? error.message : String(error);
+      this.setConnectionStatus("Disconnected");
+      this.enqueueError(`Could not connect to CatUI with \`${this.settings.command} ${this.settings.args}\`.\n${message}`);
+      throw error;
+    }
+  }
+
+  runPromptAsStream(userText: string, abortSignal?: AbortSignal): ReadableStream<UIMessageChunk> {
+    const textId = `catui-text-${Date.now()}`;
+    return new ReadableStream<UIMessageChunk>({
+      start: (controller) => {
+        const turn: ActiveTurn = { controller, textId, textStarted: false, closed: false };
+        this.activeTurn = turn;
+        controller.enqueue({ type: "start" });
+        controller.enqueue({ type: "start-step" });
+
+        const abort = () => {
+          this.client?.cancel();
+          this.closeTurn(turn, "abort");
+        };
+        abortSignal?.addEventListener("abort", abort, { once: true });
+
+        void this.sendPrompt(userText)
+          .then(() => this.closeTurn(turn, "finish"))
+          .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            this.enqueueError(message);
+            this.closeTurn(turn, "finish");
+          })
+          .finally(() => abortSignal?.removeEventListener("abort", abort));
+      },
+      cancel: () => {
+        this.client?.cancel();
+      },
+    });
+  }
+
+  cancelPrompt(): void {
+    this.client?.cancel();
+    this.enqueueError("Cancel requested.");
+  }
+
+  restartClient(): void {
+    this.process.stop();
+    this.client = null;
+    this.setConnectionStatus("Disconnected");
+    void this.ensureClient();
+  }
+
+  async startNewSession(): Promise<void> {
+    await this.ensureClient();
+    const session = await this.client!.newSession();
+    this.closedSessionIds.delete(session.sessionId);
+    this.setActiveSessionId(session.sessionId);
+    await this.client!.setMode(this.settings.defaultMode);
+    await this.refreshSessions();
+    new Notice("Started a new CatUI session.");
+  }
+
+  async loadSession(sessionId: string): Promise<void> {
+    await this.ensureClient();
+    await this.client!.loadSession(sessionId);
+    this.closedSessionIds.delete(sessionId);
+    this.setActiveSessionId(sessionId);
+    await this.client!.setMode(this.settings.defaultMode);
+    await this.refreshSessions();
+  }
+
+  async closeSession(sessionId: string): Promise<void> {
+    await this.ensureClient();
+    try {
+      await this.client!.closeSession(sessionId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("Method not found")) {
+        new Notice(`Could not close CatUI session: ${message}`);
+      }
+    }
+    this.closedSessionIds.add(sessionId);
+    if (this.activeSessionId === sessionId) this.setActiveSessionId(null);
+    await this.refreshSessions();
+  }
+
+  async closeAllSessions(): Promise<void> {
+    await this.ensureClient();
+    const sessions = [...this.sessions];
+    await Promise.allSettled(sessions.map((session) => this.client!.closeSession(session.sessionId)));
+    for (const session of sessions) this.closedSessionIds.add(session.sessionId);
+    this.setActiveSessionId(null);
+    await this.refreshSessions();
+  }
+
+  async showSessions(): Promise<void> {
+    const result = await this.refreshSessions();
+    new Notice(`${result.sessions.length} CatUI sessions found.`);
+  }
+
+  async refreshSessions(): Promise<AcpListSessionsResult> {
+    await this.ensureClient();
+    const result = await this.client!.listSessions();
+    this.setSessions(result.sessions.filter((session) => !this.closedSessionIds.has(session.sessionId)));
+    return result;
+  }
+
+  subscribeStatus(listener: (status: CatuiConnectionStatus) => void): () => void {
+    this.statusListeners.add(listener);
+    listener(this.connectionStatus);
+    return () => this.statusListeners.delete(listener);
+  }
+
+  subscribePermission(listener: (permission: PendingPermission | null) => void): () => void {
+    this.permissionListeners.add(listener);
+    listener(this.pendingPermission);
+    return () => this.permissionListeners.delete(listener);
+  }
+
+  subscribeSessions(listener: (state: { activeSessionId: string | null; sessions: CatuiSessionSummary[] }) => void): () => void {
+    this.sessionListeners.add(listener);
+    listener({ activeSessionId: this.activeSessionId, sessions: this.sessions });
+    return () => this.sessionListeners.delete(listener);
+  }
+
+  resolvePermission(choice: PermissionChoice): void {
+    this.permissionResolver?.(choice);
+  }
+
+  async loadSettings(): Promise<void> {
+    this.settings = { ...DEFAULT_SETTINGS, ...(await this.loadData()) };
+  }
+
+  async saveSettings(): Promise<void> {
+    await this.saveData(this.settings);
+  }
+
+  private handleSessionUpdate(params: AcpSessionUpdateParams): void {
+    const update = params.update;
+    if (update.sessionUpdate === "agent_message_chunk") {
+      const text = getContentText(update.content);
+      if (text) this.enqueueText(text);
+      return;
+    }
+    if (update.sessionUpdate === "agent_thought_chunk") return;
+    if (update.sessionUpdate === "tool_call") {
+      this.enqueueChunk({
+        type: "tool-input-available",
+        toolCallId: String(update.toolCallId ?? `tool-${Date.now()}`),
+        toolName: String(update.title ?? "tool"),
+        input: update.rawInput ?? {},
+        dynamic: true,
+        title: String(update.title ?? "tool"),
+      });
+      return;
+    }
+    if (update.sessionUpdate === "tool_call_update") {
+      const toolCallId = String(update.toolCallId ?? `tool-${Date.now()}`);
+      if (update.status === "failed") {
+        this.enqueueChunk({
+          type: "tool-output-error",
+          toolCallId,
+          errorText: toolPayloadToText(update.rawOutput ?? update.content),
+          dynamic: true,
+        });
+      } else {
+        this.enqueueChunk({
+          type: "tool-output-available",
+          toolCallId,
+          output: update.rawOutput ?? update.content ?? {},
+          dynamic: true,
+        });
+      }
+      return;
+    }
+    if (update.sessionUpdate === "current_mode_update" && typeof update.currentModeId === "string") {
+      new Notice(`CatUI mode: ${update.currentModeId}`);
+    }
+  }
+
+  private handlePermissionRequest(params: AcpPermissionRequestParams, resolve: (value: unknown) => void): void {
+    const risk = classifyPermissionRisk({
+      protectRawWrites: this.settings.protectRawWrites,
+      rawInput: params.toolCall?.rawInput,
+    });
+
+    if (risk.level === "blocked") {
+      this.enqueueError(`Blocked permission request: ${risk.reason}`);
+      resolve(createPermissionOutcome("reject_once"));
+      return;
+    }
+
+    let settled = false;
+    const choose = (choice: PermissionChoice): void => {
+      if (settled) return;
+      settled = true;
+      resolve(createPermissionOutcome(choice));
+      this.permissionResolver = null;
+      this.setPendingPermission(null);
+      if (choice.startsWith("reject")) this.enqueueError(`Permission response: ${choice}`);
+    };
+
+    this.permissionResolver = choose;
+    this.setPendingPermission({
+      title: params.toolCall?.title ?? "Tool call",
+      detail: `${risk.reason}\n${JSON.stringify(params.toolCall?.rawInput ?? {}, null, 2)}`,
+    });
+  }
+
+  private async sendPrompt(userText: string): Promise<void> {
+    await this.ensureClient();
+    if (!this.activeSessionId || !this.client!.sessionId) {
+      const session = await this.client!.newSession();
+      this.closedSessionIds.delete(session.sessionId);
+      this.setActiveSessionId(session.sessionId);
+      await this.client!.setMode(this.settings.defaultMode);
+      void this.refreshSessions();
+    }
+    const activeFile = this.app.workspace.getActiveFile();
+    const selection = this.app.workspace.activeEditor?.editor?.getSelection() ?? "";
+    const prompt = buildPromptWithVaultContext({
+      userText,
+      activePath: activeFile?.path ?? null,
+      selection,
+      includeActiveNote: this.settings.includeActiveNote,
+      includeSelection: this.settings.includeSelection,
+      personality: this.settings.personality,
+    });
+    await this.client!.prompt(prompt);
+  }
+
+  private setConnectionStatus(status: CatuiConnectionStatus): void {
+    this.connectionStatus = status;
+    for (const listener of this.statusListeners) listener(status);
+  }
+
+  private setPendingPermission(permission: PendingPermission | null): void {
+    this.pendingPermission = permission;
+    for (const listener of this.permissionListeners) listener(permission);
+  }
+
+  private setActiveSessionId(sessionId: string | null): void {
+    this.activeSessionId = sessionId;
+    this.emitSessionState();
+  }
+
+  private setSessions(sessions: CatuiSessionSummary[]): void {
+    this.sessions = sessions;
+    this.emitSessionState();
+  }
+
+  private emitSessionState(): void {
+    const state = { activeSessionId: this.activeSessionId, sessions: this.sessions };
+    for (const listener of this.sessionListeners) listener(state);
+  }
+
+  private enqueueText(text: string): void {
+    const turn = this.activeTurn;
+    if (!turn || turn.closed) return;
+    if (!turn.textStarted) {
+      turn.controller.enqueue({ type: "text-start", id: turn.textId });
+      turn.textStarted = true;
+    }
+    turn.controller.enqueue({ type: "text-delta", id: turn.textId, delta: text });
+  }
+
+  private enqueueError(errorText: string): void {
+    if (!errorText) return;
+    const turn = this.activeTurn;
+    if (!turn || turn.closed) {
+      this.recordRuntimeError(`enqueueError (no active turn): ${errorText}`);
+      return;
+    }
+    try {
+      turn.controller.enqueue({ type: "error", errorText });
+    } catch (error) {
+      this.recordRuntimeError(`enqueueError (controller rejected): ${errorText} :: ${String(error)}`);
+    }
+  }
+
+  private enqueueChunk(chunk: UIMessageChunk): void {
+    const turn = this.activeTurn;
+    if (!turn || turn.closed) return;
+    try {
+      turn.controller.enqueue(chunk);
+    } catch (error) {
+      this.recordRuntimeError(`enqueueChunk (controller rejected): ${String(error)}`);
+    }
+  }
+
+  private closeTurn(turn: ActiveTurn, type: "finish" | "abort"): void {
+    if (turn.closed) return;
+    turn.closed = true;
+    if (turn.textStarted) turn.controller.enqueue({ type: "text-end", id: turn.textId });
+    turn.controller.enqueue({ type: "finish-step" });
+    turn.controller.enqueue(type === "abort" ? { type: "abort", reason: "cancelled" } : { type: "finish", finishReason: "stop" });
+    turn.controller.close();
+    if (this.activeTurn === turn) this.activeTurn = null;
+  }
+
+  private getVaultBasePath(): string {
+    const adapter = this.app.vault.adapter as unknown as Partial<FileSystemAdapterLike>;
+    const basePath = adapter.getBasePath?.();
+    if (!basePath) throw new Error("CatUI ACP requires an Obsidian desktop file-system vault.");
+    return basePath;
+  }
+
+  subscribeDiagnostics(listener: (snapshot: PluginDiagnostics) => void): () => void {
+    this.diagnosticsListeners.add(listener);
+    return () => this.diagnosticsListeners.delete(listener);
+  }
+
+  getDiagnostics(): PluginDiagnostics {
+    const version = (this.manifest as { version?: string })?.version ?? "0.0.0";
+    const obsidianVersion = (this.app as unknown as { version?: string }).version ?? "unknown";
+    return {
+      pluginVersion: version,
+      obsidianVersion,
+      startedAt: this.startedAt,
+      loadEvents: [...this.loadEvents],
+      runtimeErrors: [...this.runtimeErrors],
+      stderrTail: this.process.stderrText.slice(-4000),
+      stderrTotal: this.process.stderrText.length,
+      activeCommand: `${this.settings.command} ${this.settings.args}`.trim(),
+    };
+  }
+
+  private installGlobalErrorHandlers(): void {
+    this.registerDomEvent(window, "error", (event) => {
+      const message = (event as ErrorEvent).message ?? String((event as ErrorEvent).error ?? "unknown");
+      const stack = ((event as ErrorEvent).error as Error | undefined)?.stack ?? "";
+      this.recordRuntimeError(`window.error: ${message}${stack ? `\n${stack}` : ""}`);
+    });
+    this.registerDomEvent(window, "unhandledrejection", (event) => {
+      const reason = (event as PromiseRejectionEvent).reason;
+      const message = reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : String(reason);
+      this.recordRuntimeError(`unhandledrejection: ${message}`);
+    });
+  }
+
+  private recordLoadEvent(event: string): void {
+    const stamp = new Date().toISOString().slice(11, 23);
+    this.loadEvents.push(`[${stamp}] ${event}`);
+    if (this.loadEvents.length > DIAGNOSTICS_BUFFER_LIMIT) this.loadEvents.shift();
+    this.emitDiagnostics();
+  }
+
+  private recordRuntimeError(text: string): void {
+    const stamp = new Date().toISOString().slice(11, 23);
+    this.runtimeErrors.push(`[${stamp}] ${text}`);
+    if (this.runtimeErrors.length > DIAGNOSTICS_BUFFER_LIMIT) this.runtimeErrors.shift();
+    this.emitDiagnostics();
+  }
+
+  private emitDiagnostics(): void {
+    const snapshot = this.getDiagnostics();
+    for (const listener of this.diagnosticsListeners) listener(snapshot);
+  }
+}
+
+function getContentText(content: unknown): string {
+  if (content && typeof content === "object" && "text" in content) {
+    const text = (content as { text?: unknown }).text;
+    return typeof text === "string" ? text : "";
+  }
+  return "";
+}
+
+function toolPayloadToText(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}

package/src/policy/permission-policy.ts

@@ -0,0 +1,52 @@
+import type { AcpPermissionResponse } from "../acp/types";
+
+export type PermissionRisk =
+  | { level: "blocked"; reason: string }
+  | { level: "review"; reason: string };
+
+export interface PermissionRiskInput {
+  protectRawWrites: boolean;
+  rawInput: unknown;
+}
+
+export type PermissionChoice =
+  | "allow_once"
+  | "allow_always"
+  | "reject_once"
+  | "reject_always"
+  | "cancelled";
+
+export function classifyPermissionRisk(input: PermissionRiskInput): PermissionRisk {
+  if (input.protectRawWrites && containsRawPath(input.rawInput)) {
+    return {
+      level: "blocked",
+      reason: "This operation appears to modify raw/. raw sources are immutable in this LLM-Wiki.",
+    };
+  }
+
+  return {
+    level: "review",
+    reason: "Review the requested tool call before allowing CatUI to continue.",
+  };
+}
+
+export function createPermissionOutcome(choice: PermissionChoice): AcpPermissionResponse {
+  if (choice === "cancelled") {
+    return { outcome: { outcome: "cancelled" } };
+  }
+  return { outcome: { outcome: "selected", optionId: choice } };
+}
+
+function containsRawPath(value: unknown): boolean {
+  if (typeof value === "string") return isRawPathString(value);
+  if (Array.isArray(value)) return value.some(containsRawPath);
+  if (value && typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some(containsRawPath);
+  }
+  return false;
+}
+
+function isRawPathString(value: string): boolean {
+  const normalized = value.replaceAll("\\", "/");
+  return normalized === "raw" || normalized.includes("/raw/") || normalized.startsWith("raw/");
+}