@mseep/claudian 2.0.25

package/src/providers/claude/runtime/ClaudeQueryOptionsBuilder.ts

@@ -0,0 +1,315 @@
+import type {
+  CanUseTool,
+  Options,
+  PermissionMode as SDKPermissionMode,
+} from '@anthropic-ai/claude-agent-sdk';
+
+import type { McpServerManager } from '../../../core/mcp/McpServerManager';
+import {
+  buildSystemPrompt,
+  computeSystemPromptKey,
+  type SystemPromptSettings,
+} from '../../../core/prompt/mainAgent';
+import type { AppPluginManager } from '../../../core/providers/types';
+import type { ClaudianSettings, PermissionMode } from '../../../core/types/settings';
+import { toClaudeRuntimeModelId } from '../modelSelection';
+import {
+  type ClaudeSafeMode,
+  getClaudeProviderSettings,
+  resolveClaudeSettingSources,
+} from '../settings';
+import {
+  resolveEffortLevel,
+} from '../types/models';
+import { createCustomSpawnFunction } from './customSpawn';
+import {
+  DISABLED_BUILTIN_SUBAGENTS,
+  type PersistentQueryConfig,
+  UNSUPPORTED_SDK_TOOLS,
+} from './types';
+
+export interface QueryOptionsContext {
+  vaultPath: string;
+  cliPath: string;
+  settings: ClaudianSettings;
+  customEnv: Record<string, string>;
+  enhancedPath: string;
+  mcpManager: McpServerManager;
+  pluginManager: AppPluginManager;
+}
+
+export interface PersistentQueryContext extends QueryOptionsContext {
+  abortController?: AbortController;
+  resume?: {
+    sessionId: string;
+    sessionAt?: string;
+    fork?: boolean;
+  };
+  canUseTool?: CanUseTool;
+  hooks: Options['hooks'];
+  externalContextPaths?: string[];
+}
+
+export interface ColdStartQueryContext extends QueryOptionsContext {
+  abortController?: AbortController;
+  sessionId?: string;
+  modelOverride?: string;
+  canUseTool?: CanUseTool;
+  hooks: Options['hooks'];
+  mcpMentions?: Set<string>;
+  enabledMcpServers?: Set<string>;
+  allowedTools?: string[];
+  hasEditorContext: boolean;
+  externalContextPaths?: string[];
+}
+
+export class QueryOptionsBuilder {
+  static needsRestart(
+    currentConfig: PersistentQueryConfig | null,
+    newConfig: PersistentQueryConfig
+  ): boolean {
+    if (!currentConfig) return true;
+
+    // These require restart (cannot be updated dynamically)
+    if (currentConfig.systemPromptKey !== newConfig.systemPromptKey) return true;
+    if (currentConfig.disallowedToolsKey !== newConfig.disallowedToolsKey) return true;
+    if (currentConfig.pluginsKey !== newConfig.pluginsKey) return true;
+    if (currentConfig.settingSources !== newConfig.settingSources) return true;
+    if (currentConfig.claudeCliPath !== newConfig.claudeCliPath) return true;
+
+    // Note: Permission mode is handled dynamically via setPermissionMode() in ClaudianService.
+    // Since allowDangerouslySkipPermissions is always true, both directions work without restart.
+
+    if (currentConfig.enableChrome !== newConfig.enableChrome) return true;
+    if (currentConfig.enableAutoMode !== newConfig.enableAutoMode) return true;
+
+    // External context paths require restart (additionalDirectories can't be updated dynamically)
+    if (QueryOptionsBuilder.pathsChanged(currentConfig.externalContextPaths, newConfig.externalContextPaths)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  static buildPersistentQueryConfig(
+    ctx: QueryOptionsContext,
+    externalContextPaths?: string[]
+  ): PersistentQueryConfig {
+    const claudeSettings = getClaudeProviderSettings(ctx.settings);
+    const systemPromptSettings: SystemPromptSettings = {
+      mediaFolder: ctx.settings.mediaFolder,
+      customPrompt: ctx.settings.systemPrompt,
+      vaultPath: ctx.vaultPath,
+      userName: ctx.settings.userName,
+    };
+
+    const sdkPermissionMode = QueryOptionsBuilder.resolveClaudeSdkPermissionMode(
+      ctx.settings.permissionMode,
+      claudeSettings.safeMode,
+    );
+
+    const disallowedToolsKey = ctx.mcpManager.getAllDisallowedMcpTools().join('|');
+    const pluginsKey = ctx.pluginManager.getPluginsKey();
+
+    const settingSources = resolveClaudeSettingSources(claudeSettings.loadUserSettings);
+    const runtimeModel = toClaudeRuntimeModelId(ctx.settings.model);
+
+    return {
+      model: runtimeModel,
+      effortLevel: resolveEffortLevel(runtimeModel, ctx.settings.effortLevel),
+      permissionMode: ctx.settings.permissionMode,
+      sdkPermissionMode,
+      systemPromptKey: computeSystemPromptKey(systemPromptSettings),
+      disallowedToolsKey,
+      mcpServersKey: '', // Dynamic via setMcpServers, not tracked for restart
+      pluginsKey,
+      externalContextPaths: externalContextPaths || [],
+      settingSources: settingSources.join(','),
+      claudeCliPath: ctx.cliPath,
+      enableChrome: claudeSettings.enableChrome,
+      enableAutoMode: claudeSettings.safeMode === 'auto',
+    };
+  }
+
+  static buildPersistentQueryOptions(ctx: PersistentQueryContext): Options {
+    const runtimeModel = toClaudeRuntimeModelId(ctx.settings.model);
+    const { options, claudeSettings } = QueryOptionsBuilder.buildBaseOptions(
+      ctx,
+      runtimeModel,
+      ctx.abortController,
+    );
+
+    options.disallowedTools = [
+      ...ctx.mcpManager.getAllDisallowedMcpTools(),
+      ...UNSUPPORTED_SDK_TOOLS,
+      ...DISABLED_BUILTIN_SUBAGENTS,
+    ];
+
+    QueryOptionsBuilder.applyPermissionMode(
+      options,
+      ctx.settings.permissionMode,
+      claudeSettings.safeMode,
+      ctx.canUseTool,
+    );
+    QueryOptionsBuilder.applyThinking(options, ctx.settings, runtimeModel);
+    options.hooks = ctx.hooks;
+
+    options.enableFileCheckpointing = true;
+
+    if (ctx.resume) {
+      options.resume = ctx.resume.sessionId;
+      if (ctx.resume.sessionAt) {
+        options.resumeSessionAt = ctx.resume.sessionAt;
+      }
+      if (ctx.resume.fork) {
+        options.forkSession = true;
+      }
+    }
+
+    if (ctx.externalContextPaths && ctx.externalContextPaths.length > 0) {
+      options.additionalDirectories = ctx.externalContextPaths;
+    }
+
+    return options;
+  }
+
+  static buildColdStartQueryOptions(ctx: ColdStartQueryContext): Options {
+    const selectedModel = toClaudeRuntimeModelId(ctx.modelOverride ?? ctx.settings.model);
+    const { options, claudeSettings } = QueryOptionsBuilder.buildBaseOptions(
+      ctx,
+      selectedModel,
+      ctx.abortController,
+    );
+
+    const mcpMentions = ctx.mcpMentions || new Set<string>();
+    const uiEnabledServers = ctx.enabledMcpServers || new Set<string>();
+    const combinedMentions = new Set([...mcpMentions, ...uiEnabledServers]);
+    const mcpServers = ctx.mcpManager.getActiveServers(combinedMentions);
+
+    if (Object.keys(mcpServers).length > 0) {
+      options.mcpServers = mcpServers;
+    }
+
+    const disallowedMcpTools = ctx.mcpManager.getDisallowedMcpTools(combinedMentions);
+    options.disallowedTools = [
+      ...disallowedMcpTools,
+      ...UNSUPPORTED_SDK_TOOLS,
+      ...DISABLED_BUILTIN_SUBAGENTS,
+    ];
+
+    QueryOptionsBuilder.applyPermissionMode(
+      options,
+      ctx.settings.permissionMode,
+      claudeSettings.safeMode,
+      ctx.canUseTool,
+    );
+    options.hooks = ctx.hooks;
+    QueryOptionsBuilder.applyThinking(options, ctx.settings, selectedModel);
+
+    if (ctx.allowedTools !== undefined && ctx.allowedTools.length > 0) {
+      options.tools = ctx.allowedTools;
+    }
+
+    if (ctx.sessionId) {
+      options.resume = ctx.sessionId;
+    }
+
+    if (ctx.externalContextPaths && ctx.externalContextPaths.length > 0) {
+      options.additionalDirectories = ctx.externalContextPaths;
+    }
+
+    return options;
+  }
+
+  static resolveClaudeSdkPermissionMode(
+    permissionMode: PermissionMode,
+    claudeSafeMode: ClaudeSafeMode = 'acceptEdits',
+  ): SDKPermissionMode {
+    if (permissionMode === 'yolo') return 'bypassPermissions';
+    if (permissionMode === 'plan') return 'plan';
+    return claudeSafeMode;
+  }
+
+  private static applyPermissionMode(
+    options: Options,
+    permissionMode: PermissionMode,
+    claudeSafeMode: ClaudeSafeMode,
+    canUseTool?: CanUseTool
+  ): void {
+    options.allowDangerouslySkipPermissions = true;
+
+    if (canUseTool) {
+      options.canUseTool = canUseTool;
+    }
+
+    options.permissionMode = QueryOptionsBuilder.resolveClaudeSdkPermissionMode(
+      permissionMode,
+      claudeSafeMode,
+    );
+  }
+
+  private static applyExtraArgs(
+    options: Options,
+    settings: { enableChrome: boolean; safeMode: ClaudeSafeMode },
+  ): void {
+    if (settings.safeMode === 'auto') {
+      options.extraArgs = { ...options.extraArgs, 'enable-auto-mode': null };
+    }
+
+    if (settings.enableChrome) {
+      options.extraArgs = { ...options.extraArgs, chrome: null };
+    }
+  }
+
+  private static buildBaseOptions(
+    ctx: QueryOptionsContext,
+    model: string,
+    abortController?: AbortController,
+  ): { options: Options; claudeSettings: ReturnType<typeof getClaudeProviderSettings> } {
+    const claudeSettings = getClaudeProviderSettings(ctx.settings);
+    const systemPromptSettings: SystemPromptSettings = {
+      mediaFolder: ctx.settings.mediaFolder,
+      customPrompt: ctx.settings.systemPrompt,
+      vaultPath: ctx.vaultPath,
+      userName: ctx.settings.userName,
+    };
+    const options: Options = {
+      cwd: ctx.vaultPath,
+      systemPrompt: buildSystemPrompt(systemPromptSettings),
+      model,
+      abortController,
+      pathToClaudeCodeExecutable: ctx.cliPath,
+      settingSources: resolveClaudeSettingSources(claudeSettings.loadUserSettings),
+      env: {
+        ...process.env,
+        ...ctx.customEnv,
+        PATH: ctx.enhancedPath,
+      },
+      includePartialMessages: true,
+    };
+
+    QueryOptionsBuilder.applyExtraArgs(options, claudeSettings);
+    options.spawnClaudeCodeProcess = createCustomSpawnFunction(ctx.enhancedPath);
+
+    return { options, claudeSettings };
+  }
+
+  private static applyThinking(
+    options: Options,
+    settings: ClaudianSettings,
+    model: string
+  ): void {
+    const effortLevel = resolveEffortLevel(model, settings.effortLevel);
+    options.thinking = { type: 'adaptive' };
+    // SDK runtime accepts `xhigh` on Opus 4.7+ and silently falls back to
+    // `high` elsewhere, but its type definition lags our local EffortLevel.
+    options.effort = effortLevel;
+  }
+
+  private static pathsChanged(a?: string[], b?: string[]): boolean {
+    const aKey = [...(a || [])].sort().join('|');
+    const bKey = [...(b || [])].sort().join('|');
+    return aKey !== bKey;
+  }
+
+}

package/src/providers/claude/runtime/ClaudeRewindService.ts

@@ -0,0 +1,220 @@
+import type { RewindFilesResult } from '@anthropic-ai/claude-agent-sdk';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+
+import type { ChatRewindMode, ChatRewindResult } from '../../../core/runtime/types';
+
+interface BackupEntryFile {
+  originalPath: string;
+  existedBefore: true;
+  kind: 'file' | 'dir';
+  backupPath: string;
+}
+
+interface BackupEntrySymlink {
+  originalPath: string;
+  existedBefore: true;
+  kind: 'symlink';
+  symlinkTarget: string;
+}
+
+interface BackupEntryMissing {
+  originalPath: string;
+  existedBefore: false;
+}
+
+type BackupEntry = BackupEntryFile | BackupEntrySymlink | BackupEntryMissing;
+
+export interface ClaudeRewindBackup {
+  restore: () => Promise<void>;
+  cleanup: () => Promise<void>;
+}
+
+export interface ExecuteClaudeRewindDeps {
+  assistantMessageId: string;
+  mode: ChatRewindMode;
+  rewindFiles: (userMessageId: string, dryRun?: boolean) => Promise<RewindFilesResult>;
+  closePersistentQuery: (reason: string) => void;
+  setPendingResumeAt: (assistantMessageId: string) => void;
+  vaultPath: string | null;
+}
+
+function resolveRewindFilePath(filePath: string, vaultPath: string | null): string {
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  if (vaultPath) {
+    return path.join(vaultPath, filePath);
+  }
+  return filePath;
+}
+
+async function copyDir(from: string, to: string): Promise<void> {
+  await fs.mkdir(to, { recursive: true });
+  const dirents = await fs.readdir(from, { withFileTypes: true });
+  for (const dirent of dirents) {
+    const srcPath = path.join(from, dirent.name);
+    const destPath = path.join(to, dirent.name);
+
+    if (dirent.isDirectory()) {
+      await copyDir(srcPath, destPath);
+      continue;
+    }
+
+    if (dirent.isSymbolicLink()) {
+      const target = await fs.readlink(srcPath);
+      await fs.symlink(target, destPath);
+      continue;
+    }
+
+    if (dirent.isFile()) {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+export async function createClaudeRewindBackup(
+  filesChanged: string[] | undefined,
+  vaultPath: string | null,
+): Promise<ClaudeRewindBackup | null> {
+  if (!filesChanged || filesChanged.length === 0) {
+    return null;
+  }
+
+  const backupRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'claudian-rewind-'));
+  const entries: BackupEntry[] = [];
+  const backupPathForIndex = (index: number) => path.join(backupRoot, String(index));
+
+  for (let i = 0; i < filesChanged.length; i++) {
+    const originalPath = resolveRewindFilePath(filesChanged[i], vaultPath);
+
+    try {
+      const stats = await fs.lstat(originalPath);
+
+      if (stats.isSymbolicLink()) {
+        const target = await fs.readlink(originalPath);
+        entries.push({ originalPath, existedBefore: true, kind: 'symlink', symlinkTarget: target });
+        continue;
+      }
+
+      const backupPath = backupPathForIndex(i);
+      if (stats.isDirectory()) {
+        await copyDir(originalPath, backupPath);
+        entries.push({ originalPath, existedBefore: true, kind: 'dir', backupPath });
+        continue;
+      }
+
+      if (stats.isFile()) {
+        await fs.copyFile(originalPath, backupPath);
+        entries.push({ originalPath, existedBefore: true, kind: 'file', backupPath });
+        continue;
+      }
+
+      entries.push({ originalPath, existedBefore: false });
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err.code === 'ENOENT') {
+        entries.push({ originalPath, existedBefore: false });
+        continue;
+      }
+
+      await fs.rm(backupRoot, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  const restore = async () => {
+    const errors: unknown[] = [];
+
+    for (const entry of entries) {
+      try {
+        if (!entry.existedBefore) {
+          await fs.rm(entry.originalPath, { recursive: true, force: true });
+          continue;
+        }
+
+        await fs.rm(entry.originalPath, { recursive: true, force: true });
+        await fs.mkdir(path.dirname(entry.originalPath), { recursive: true });
+
+        if (entry.kind === 'symlink') {
+          await fs.symlink(entry.symlinkTarget, entry.originalPath);
+          continue;
+        }
+
+        if (entry.kind === 'dir') {
+          await copyDir(entry.backupPath, entry.originalPath);
+          continue;
+        }
+
+        await fs.copyFile(entry.backupPath, entry.originalPath);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Failed to restore ${errors.length} file(s) after rewind failure.`);
+    }
+  };
+
+  const cleanup = async () => {
+    await fs.rm(backupRoot, { recursive: true, force: true });
+  };
+
+  return { restore, cleanup };
+}
+
+export async function executeClaudeRewind(
+  userMessageId: string,
+  deps: ExecuteClaudeRewindDeps,
+): Promise<ChatRewindResult> {
+  if (deps.mode === 'conversation') {
+    deps.setPendingResumeAt(deps.assistantMessageId);
+    deps.closePersistentQuery('conversation rewind');
+    return { canRewind: true, filesChanged: [] };
+  }
+
+  const preview = await deps.rewindFiles(userMessageId, true);
+  if (!preview.canRewind) {
+    return preview;
+  }
+
+  const backup = await createClaudeRewindBackup(preview.filesChanged, deps.vaultPath);
+
+  try {
+    const result = await deps.rewindFiles(userMessageId);
+    if (!result.canRewind) {
+      await backup?.restore();
+      deps.closePersistentQuery('rewind failed');
+      return result;
+    }
+
+    deps.setPendingResumeAt(deps.assistantMessageId);
+    deps.closePersistentQuery('rewind');
+    return {
+      ...result,
+      filesChanged: preview.filesChanged,
+      insertions: preview.insertions,
+      deletions: preview.deletions,
+    };
+  } catch (error) {
+    try {
+      await backup?.restore();
+    } catch (rollbackError) {
+      deps.closePersistentQuery('rewind failed');
+      throw new Error(
+        `Rewind failed and files could not be fully restored: ${rollbackError instanceof Error ? rollbackError.message : 'Unknown error'}`,
+        { cause: rollbackError },
+      );
+    }
+
+    deps.closePersistentQuery('rewind failed');
+    throw new Error(
+      `Rewind failed but files were restored: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      { cause: error },
+    );
+  } finally {
+    await backup?.cleanup();
+  }
+}

package/src/providers/claude/runtime/ClaudeSessionManager.ts

@@ -0,0 +1,92 @@
+import type { ClaudeModel } from '../types/models';
+import type { SessionState } from './types';
+
+export class SessionManager {
+  private state: SessionState = {
+    sessionId: null,
+    sessionModel: null,
+    pendingSessionModel: null,
+    wasInterrupted: false,
+    needsHistoryRebuild: false,
+    sessionInvalidated: false,
+  };
+
+  getSessionId(): string | null {
+    return this.state.sessionId;
+  }
+
+  setSessionId(id: string | null, defaultModel?: ClaudeModel): void {
+    this.state.sessionId = id;
+    this.state.sessionModel = id ? (defaultModel ?? null) : null;
+    // Clear rebuild flag when switching sessions to prevent carrying over to different conversation
+    this.state.needsHistoryRebuild = false;
+    // Clear invalidation flag when explicitly setting session
+    this.state.sessionInvalidated = false;
+  }
+
+  wasInterrupted(): boolean {
+    return this.state.wasInterrupted;
+  }
+
+  markInterrupted(): void {
+    this.state.wasInterrupted = true;
+  }
+
+  clearInterrupted(): void {
+    this.state.wasInterrupted = false;
+  }
+
+  setPendingModel(model: ClaudeModel): void {
+    this.state.pendingSessionModel = model;
+  }
+
+  clearPendingModel(): void {
+    this.state.pendingSessionModel = null;
+  }
+
+  captureSession(sessionId: string): void {
+    const hadSession = this.state.sessionId !== null;
+    const isDifferent = this.state.sessionId !== sessionId;
+    if (hadSession && isDifferent) {
+      // SDK lost our session context - need to rebuild history on next message
+      this.state.needsHistoryRebuild = true;
+    }
+
+    this.state.sessionId = sessionId;
+    this.state.sessionModel = this.state.pendingSessionModel;
+    this.state.pendingSessionModel = null;
+    this.state.sessionInvalidated = false;
+  }
+
+  needsHistoryRebuild(): boolean {
+    return this.state.needsHistoryRebuild;
+  }
+
+  clearHistoryRebuild(): void {
+    this.state.needsHistoryRebuild = false;
+  }
+
+  invalidateSession(): void {
+    this.state.sessionId = null;
+    this.state.sessionModel = null;
+    this.state.sessionInvalidated = true;
+  }
+
+  /** Consume the invalidation flag (returns true once). */
+  consumeInvalidation(): boolean {
+    const wasInvalidated = this.state.sessionInvalidated;
+    this.state.sessionInvalidated = false;
+    return wasInvalidated;
+  }
+
+  reset(): void {
+    this.state = {
+      sessionId: null,
+      sessionModel: null,
+      pendingSessionModel: null,
+      wasInterrupted: false,
+      needsHistoryRebuild: false,
+      sessionInvalidated: false,
+    };
+  }
+}