@mseep/claudian 2.0.25

package/src/core/runtime/types.ts

@@ -0,0 +1,118 @@
+import type { BrowserSelectionContext } from '../../utils/browser';
+import type { CanvasSelectionContext } from '../../utils/canvas';
+import type { EditorSelectionContext } from '../../utils/editor';
+import type {
+  ApprovalDecision,
+  Conversation,
+  ExitPlanModeCallback,
+  ImageAttachment,
+  StreamChunk,
+} from '../types';
+
+export interface ApprovalDecisionOption {
+  label: string;
+  description?: string;
+  value: string;
+  decision?: ApprovalDecision;
+}
+
+export interface ApprovalNetworkContext {
+  host: string;
+  protocol: string;
+}
+
+export interface ApprovalCallbackOptions {
+  decisionReason?: string;
+  blockedPath?: string;
+  agentID?: string;
+  decisionOptions?: ApprovalDecisionOption[];
+  networkApprovalContext?: ApprovalNetworkContext;
+  additionalPermissions?: unknown;
+}
+
+export type ApprovalCallback = (
+  toolName: string,
+  input: Record<string, unknown>,
+  description: string,
+  options?: ApprovalCallbackOptions,
+) => Promise<ApprovalDecision>;
+
+export type AskUserQuestionCallback = (
+  input: Record<string, unknown>,
+  signal?: AbortSignal,
+) => Promise<Record<string, string | string[]> | null>;
+
+export interface ChatTurnRequest {
+  text: string;
+  images?: ImageAttachment[];
+  currentNotePath?: string;
+  editorSelection?: EditorSelectionContext | null;
+  browserSelection?: BrowserSelectionContext | null;
+  canvasSelection?: CanvasSelectionContext | null;
+  externalContextPaths?: string[];
+  enabledMcpServers?: Set<string>;
+}
+
+export interface PreparedChatTurn {
+  request: ChatTurnRequest;
+  persistedContent: string;
+  prompt: string;
+  isCompact: boolean;
+  mcpMentions: Set<string>;
+}
+
+export interface ChatRuntimeQueryOptions {
+  allowedTools?: string[];
+  model?: string;
+  mcpMentions?: Set<string>;
+  enabledMcpServers?: Set<string>;
+  forceColdStart?: boolean;
+  externalContextPaths?: string[];
+}
+
+export interface ChatRuntimeEnsureReadyOptions {
+  allowSessionCreation?: boolean;
+  force?: boolean;
+}
+
+export type ChatRuntimeConversationState = Pick<
+  Conversation,
+  'sessionId' | 'providerState'
+>;
+
+export interface SessionUpdateResult {
+  updates: Partial<Conversation>;
+}
+
+export interface ChatRewindResult {
+  canRewind: boolean;
+  error?: string;
+  filesChanged?: string[];
+  insertions?: number;
+  deletions?: number;
+}
+
+export type ChatRewindMode = 'conversation' | 'code-and-conversation';
+
+export interface SubagentRuntimeState {
+  hasRunning: boolean;
+}
+
+export interface ChatTurnMetadata {
+  userMessageId?: string;
+  assistantMessageId?: string;
+  wasSent?: boolean;
+  planCompleted?: boolean;
+}
+
+export interface AutoTurnResult {
+  chunks: StreamChunk[];
+  metadata: ChatTurnMetadata;
+}
+
+export type AutoTurnCallback = (result: AutoTurnResult) => void | Promise<void>;
+
+export type {
+  ApprovalDecision,
+  ExitPlanModeCallback,
+};

package/src/core/security/ApprovalManager.ts

@@ -0,0 +1,142 @@
+/** Permission utilities for tool action approval. */
+
+import {
+  TOOL_BASH,
+  TOOL_EDIT,
+  TOOL_GLOB,
+  TOOL_GREP,
+  TOOL_NOTEBOOK_EDIT,
+  TOOL_READ,
+  TOOL_WRITE,
+} from '../tools/toolNames';
+
+export function getActionPattern(toolName: string, input: Record<string, unknown>): string | null {
+  switch (toolName) {
+    case TOOL_BASH:
+      return typeof input.command === 'string' ? input.command.trim() : '';
+    case TOOL_READ:
+    case TOOL_WRITE:
+    case TOOL_EDIT:
+      return typeof input.file_path === 'string' && input.file_path ? input.file_path : null;
+    case TOOL_NOTEBOOK_EDIT:
+      if (typeof input.notebook_path === 'string' && input.notebook_path) {
+        return input.notebook_path;
+      }
+      return typeof input.file_path === 'string' && input.file_path ? input.file_path : null;
+    case TOOL_GLOB:
+      return typeof input.pattern === 'string' && input.pattern ? input.pattern : null;
+    case TOOL_GREP:
+      return typeof input.pattern === 'string' && input.pattern ? input.pattern : null;
+    default:
+      return JSON.stringify(input);
+  }
+}
+
+export function getActionDescription(toolName: string, input: Record<string, unknown>): string {
+  const pattern = getActionPattern(toolName, input) ?? '(unknown)';
+  switch (toolName) {
+    case TOOL_BASH:
+      return `Run command: ${pattern}`;
+    case TOOL_READ:
+      return `Read file: ${pattern}`;
+    case TOOL_WRITE:
+      return `Write to file: ${pattern}`;
+    case TOOL_EDIT:
+      return `Edit file: ${pattern}`;
+    case TOOL_GLOB:
+      return `Search files matching: ${pattern}`;
+    case TOOL_GREP:
+      return `Search content matching: ${pattern}`;
+    default:
+      return `${toolName}: ${pattern}`;
+  }
+}
+
+/**
+ * Bash: exact or explicit wildcard ("git *", "npm:*").
+ * File tools: path-prefix matching with segment boundaries.
+ * Other tools: simple prefix matching.
+ */
+export function matchesRulePattern(
+  toolName: string,
+  actionPattern: string | null,
+  rulePattern: string | undefined
+): boolean {
+  // No rule pattern means match all
+  if (!rulePattern) return true;
+
+  // Null action pattern means we can't determine the action - don't match
+  if (actionPattern === null) return false;
+
+  const normalizedAction = actionPattern.replace(/\\/g, '/');
+  const normalizedRule = rulePattern.replace(/\\/g, '/');
+
+  // Wildcard matches everything
+  if (normalizedRule === '*') return true;
+
+  // Exact match
+  if (normalizedAction === normalizedRule) return true;
+
+  // Bash: Only exact match (handled above) or explicit wildcard patterns are allowed.
+  // This is intentional - Bash commands require explicit wildcards for security.
+  // Supported formats:
+  //   - "git *" matches "git status", "git commit", etc.
+  //   - "npm:*" matches "npm install", "npm run", etc. (CC format)
+  if (toolName === TOOL_BASH) {
+    // CC format "npm:*" — colon is a separator, not part of the prefix
+    if (normalizedRule.endsWith(':*')) {
+      const prefix = normalizedRule.slice(0, -2);
+      return matchesBashPrefix(normalizedAction, prefix);
+    }
+    // Space wildcard "git *"
+    if (normalizedRule.endsWith('*')) {
+      const prefix = normalizedRule.slice(0, -1);
+      return matchesBashPrefix(normalizedAction, prefix);
+    }
+    // No wildcard present and exact match failed above - reject
+    return false;
+  }
+
+  // File tools: prefix match with path-segment boundary awareness
+  if (
+    toolName === TOOL_READ ||
+    toolName === TOOL_WRITE ||
+    toolName === TOOL_EDIT ||
+    toolName === TOOL_NOTEBOOK_EDIT
+  ) {
+    return isPathPrefixMatch(normalizedAction, normalizedRule);
+  }
+
+  // Other tools: allow simple prefix matching
+  if (normalizedAction.startsWith(normalizedRule)) return true;
+
+  return false;
+}
+
+function isPathPrefixMatch(actionPath: string, approvedPath: string): boolean {
+  if (!actionPath.startsWith(approvedPath)) {
+    return false;
+  }
+
+  if (approvedPath.endsWith('/')) {
+    return true;
+  }
+
+  if (actionPath.length === approvedPath.length) {
+    return true;
+  }
+
+  return actionPath.charAt(approvedPath.length) === '/';
+}
+
+function matchesBashPrefix(action: string, prefix: string): boolean {
+  if (action === prefix) {
+    return true;
+  }
+
+  if (prefix.endsWith(' ')) {
+    return action.startsWith(prefix);
+  }
+
+  return action.startsWith(`${prefix} `);
+}

package/src/core/storage/HomeFileAdapter.ts

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import type { VaultFileAdapter } from './VaultFileAdapter';
+
+/**
+ * Filesystem adapter rooted at the user's home directory.
+ * Implements the same interface as VaultFileAdapter so storage
+ * classes (like CodexSkillStorage) can scan home-level paths.
+ */
+export class HomeFileAdapter implements Pick<VaultFileAdapter,
+  'exists' | 'read' | 'write' | 'delete' | 'deleteFolder' | 'listFolders' | 'ensureFolder'
+> {
+  private readonly root: string;
+
+  constructor(root: string = os.homedir()) {
+    this.root = root;
+  }
+
+  private resolve(relativePath: string): string {
+    return path.join(this.root, relativePath);
+  }
+
+  async exists(p: string): Promise<boolean> {
+    try {
+      await fs.promises.access(this.resolve(p));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async read(p: string): Promise<string> {
+    return fs.promises.readFile(this.resolve(p), 'utf-8');
+  }
+
+  async write(p: string, content: string): Promise<void> {
+    const full = this.resolve(p);
+    await fs.promises.mkdir(path.dirname(full), { recursive: true });
+    await fs.promises.writeFile(full, content, 'utf-8');
+  }
+
+  async delete(p: string): Promise<void> {
+    try {
+      await fs.promises.unlink(this.resolve(p));
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+    }
+  }
+
+  async deleteFolder(p: string): Promise<void> {
+    try {
+      await fs.promises.rmdir(this.resolve(p));
+    } catch {
+      // Non-critical
+    }
+  }
+
+  async listFolders(folder: string): Promise<string[]> {
+    const full = this.resolve(folder);
+    try {
+      const entries = await fs.promises.readdir(full, { withFileTypes: true });
+      return entries
+        .filter(e => e.isDirectory())
+        .map(e => `${folder}/${e.name}`);
+    } catch {
+      return [];
+    }
+  }
+
+  async ensureFolder(p: string): Promise<void> {
+    await fs.promises.mkdir(this.resolve(p), { recursive: true });
+  }
+}

package/src/core/storage/VaultFileAdapter.ts

@@ -0,0 +1,132 @@
+/**
+ * VaultFileAdapter - Wrapper around Obsidian Vault API for file operations.
+ *
+ * Provides a consistent interface for file operations using Obsidian's
+ * vault adapter instead of Node's fs module.
+ */
+
+import type { App } from 'obsidian';
+
+export class VaultFileAdapter {
+  private writeQueue: Promise<void> = Promise.resolve();
+
+  constructor(private app: App) {}
+
+  async exists(path: string): Promise<boolean> {
+    return this.app.vault.adapter.exists(path);
+  }
+
+  async read(path: string): Promise<string> {
+    return this.app.vault.adapter.read(path);
+  }
+
+  async write(path: string, content: string): Promise<void> {
+    await this.ensureParentFolder(path);
+    await this.app.vault.adapter.write(path, content);
+  }
+
+  async append(path: string, content: string): Promise<void> {
+    await this.ensureParentFolder(path);
+    this.writeQueue = this.writeQueue.then(async () => {
+      if (await this.exists(path)) {
+        const existing = await this.read(path);
+        await this.app.vault.adapter.write(path, existing + content);
+      } else {
+        await this.app.vault.adapter.write(path, content);
+      }
+    }).catch(() => {
+      // prevent queue from getting stuck
+    });
+    await this.writeQueue;
+  }
+
+  async delete(path: string): Promise<void> {
+    if (await this.exists(path)) {
+      await this.app.vault.adapter.remove(path);
+    }
+  }
+
+  /** Fails silently if non-empty or missing. */
+  async deleteFolder(path: string): Promise<void> {
+    try {
+      if (await this.exists(path)) {
+        await this.app.vault.adapter.rmdir(path, false);
+      }
+    } catch {
+      // Non-critical: directory may not be empty
+    }
+  }
+
+  async listFiles(folder: string): Promise<string[]> {
+    if (!(await this.exists(folder))) {
+      return [];
+    }
+    const listing = await this.app.vault.adapter.list(folder);
+    return listing.files;
+  }
+
+  /** List subfolders in a folder. Returns relative paths from the folder. */
+  async listFolders(folder: string): Promise<string[]> {
+    if (!(await this.exists(folder))) {
+      return [];
+    }
+    const listing = await this.app.vault.adapter.list(folder);
+    return listing.folders;
+  }
+
+  /** Recursively list all files in a folder and subfolders. */
+  async listFilesRecursive(folder: string): Promise<string[]> {
+    const allFiles: string[] = [];
+
+    const processFolder = async (currentFolder: string) => {
+      if (!(await this.exists(currentFolder))) return;
+
+      const listing = await this.app.vault.adapter.list(currentFolder);
+      allFiles.push(...listing.files);
+
+      for (const subfolder of listing.folders) {
+        await processFolder(subfolder);
+      }
+    };
+
+    await processFolder(folder);
+    return allFiles;
+  }
+
+  private async ensureParentFolder(filePath: string): Promise<void> {
+    const folder = filePath.substring(0, filePath.lastIndexOf('/'));
+    if (folder && !(await this.exists(folder))) {
+      await this.ensureFolder(folder);
+    }
+  }
+
+  /** Ensure a folder exists, creating it and parent folders if needed. */
+  async ensureFolder(path: string): Promise<void> {
+    if (await this.exists(path)) return;
+
+    // Create parent folders recursively
+    const parts = path.split('/').filter(Boolean);
+    let current = '';
+    for (const part of parts) {
+      current = current ? `${current}/${part}` : part;
+      if (!(await this.exists(current))) {
+        await this.app.vault.adapter.mkdir(current);
+      }
+    }
+  }
+
+  /** Rename/move a file. */
+  async rename(oldPath: string, newPath: string): Promise<void> {
+    await this.app.vault.adapter.rename(oldPath, newPath);
+  }
+
+  async stat(path: string): Promise<{ mtime: number; size: number } | null> {
+    try {
+      const stat = await this.app.vault.adapter.stat(path);
+      if (!stat) return null;
+      return { mtime: stat.mtime, size: stat.size };
+    } catch {
+      return null;
+    }
+  }
+}

package/src/core/tools/todo.ts

@@ -0,0 +1,65 @@
+/**
+ * Todo tool helpers.
+ *
+ * Parses TodoWrite tool input into typed todo items.
+ */
+
+import { TOOL_TODO_WRITE } from './toolNames';
+
+export interface TodoItem {
+  /** Imperative description (e.g., "Run tests") */
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+  /** Present continuous form (e.g., "Running tests") */
+  activeForm: string;
+}
+
+function isValidTodoItem(item: unknown): item is TodoItem {
+  if (typeof item !== 'object' || item === null) return false;
+  const record = item as Record<string, unknown>;
+  return (
+    typeof record.content === 'string' &&
+    record.content.length > 0 &&
+    typeof record.activeForm === 'string' &&
+    record.activeForm.length > 0 &&
+    typeof record.status === 'string' &&
+    ['pending', 'in_progress', 'completed'].includes(record.status)
+  );
+}
+
+export function parseTodoInput(input: Record<string, unknown>): TodoItem[] | null {
+  if (!input.todos || !Array.isArray(input.todos)) {
+    return null;
+  }
+
+  const validTodos: TodoItem[] = [];
+  for (const item of input.todos) {
+    if (isValidTodoItem(item)) {
+      validTodos.push(item);
+    }
+  }
+
+  return validTodos.length > 0 ? validTodos : null;
+}
+
+/**
+ * Extract the last TodoWrite todos from a list of messages.
+ * Used to restore the todo panel when loading a saved conversation.
+ */
+export function extractLastTodosFromMessages(
+  messages: Array<{ role: string; toolCalls?: Array<{ name: string; input: Record<string, unknown> }> }>
+): TodoItem[] | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === 'assistant' && msg.toolCalls) {
+      for (let j = msg.toolCalls.length - 1; j >= 0; j--) {
+        const toolCall = msg.toolCalls[j];
+        if (toolCall.name === TOOL_TODO_WRITE) {
+          const todos = parseTodoInput(toolCall.input);
+          return todos;
+        }
+      }
+    }
+  }
+  return null;
+}

package/src/core/tools/toolIcons.ts

@@ -0,0 +1,80 @@
+import {
+  TOOL_AGENT_OUTPUT,
+  TOOL_APPLY_PATCH,
+  TOOL_ASK_USER_QUESTION,
+  TOOL_BASH,
+  TOOL_BASH_OUTPUT,
+  TOOL_CLOSE_AGENT,
+  TOOL_EDIT,
+  TOOL_ENTER_PLAN_MODE,
+  TOOL_EXIT_PLAN_MODE,
+  TOOL_GLOB,
+  TOOL_GREP,
+  TOOL_KILL_SHELL,
+  TOOL_LIST_MCP_RESOURCES,
+  TOOL_LS,
+  TOOL_MCP,
+  TOOL_NOTEBOOK_EDIT,
+  TOOL_READ,
+  TOOL_READ_MCP_RESOURCE,
+  TOOL_RESUME_AGENT,
+  TOOL_SEND_INPUT,
+  TOOL_SKILL,
+  TOOL_SPAWN_AGENT,
+  TOOL_SUBAGENT_LEGACY,
+  TOOL_TASK,
+  TOOL_TODO_WRITE,
+  TOOL_TOOL_SEARCH,
+  TOOL_WAIT,
+  TOOL_WAIT_AGENT,
+  TOOL_WEB_FETCH,
+  TOOL_WEB_SEARCH,
+  TOOL_WRITE,
+  TOOL_WRITE_STDIN,
+} from './toolNames';
+
+const TOOL_ICONS: Record<string, string> = {
+  [TOOL_READ]: 'file-text',
+  [TOOL_WRITE]: 'file-plus',
+  [TOOL_EDIT]: 'file-pen',
+  [TOOL_NOTEBOOK_EDIT]: 'file-pen',
+  [TOOL_BASH]: 'terminal',
+  [TOOL_BASH_OUTPUT]: 'terminal',
+  [TOOL_KILL_SHELL]: 'terminal',
+  [TOOL_GLOB]: 'folder-search',
+  [TOOL_GREP]: 'search',
+  [TOOL_LS]: 'list',
+  [TOOL_TODO_WRITE]: 'list-checks',
+  [TOOL_TASK]: 'bot',
+  [TOOL_SUBAGENT_LEGACY]: 'bot',
+  [TOOL_LIST_MCP_RESOURCES]: 'list',
+  [TOOL_READ_MCP_RESOURCE]: 'file-text',
+  [TOOL_MCP]: 'wrench',
+  [TOOL_WEB_SEARCH]: 'globe',
+  [TOOL_WEB_FETCH]: 'download',
+  [TOOL_AGENT_OUTPUT]: 'bot',
+  [TOOL_ASK_USER_QUESTION]: 'help-circle',
+  [TOOL_SKILL]: 'zap',
+  [TOOL_TOOL_SEARCH]: 'search-check',
+  [TOOL_ENTER_PLAN_MODE]: 'map',
+  [TOOL_EXIT_PLAN_MODE]: 'check-circle',
+  // Runtime-managed tools
+  [TOOL_APPLY_PATCH]: 'file-pen',
+  [TOOL_WRITE_STDIN]: 'terminal',
+  [TOOL_SPAWN_AGENT]: 'bot',
+  [TOOL_SEND_INPUT]: 'bot',
+  [TOOL_WAIT]: 'clock',
+  [TOOL_WAIT_AGENT]: 'clock',
+  [TOOL_RESUME_AGENT]: 'bot',
+  [TOOL_CLOSE_AGENT]: 'bot',
+};
+
+/** Special marker for MCP tools - signals to use custom SVG. */
+export const MCP_ICON_MARKER = '__mcp_icon__';
+
+export function getToolIcon(toolName: string): string {
+  if (toolName.startsWith('mcp__')) {
+    return MCP_ICON_MARKER;
+  }
+  return TOOL_ICONS[toolName] || 'wrench';
+}