@mseep/claudian 2.0.25

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

@@ -0,0 +1,94 @@
+import * as fs from 'fs';
+
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import type { HostnameCliPaths } from '../../../core/types/settings';
+import { getHostnameKey, parseEnvironmentVariables } from '../../../utils/env';
+import { expandHomePath } from '../../../utils/path';
+import { findClaudeCLIPath } from '../cli/findClaudeCLIPath';
+import { getClaudeProviderSettings } from '../settings';
+
+export class ClaudeCliResolver {
+  private resolvedPath: string | null = null;
+  private lastHostnamePath = '';
+  private lastLegacyPath = '';
+  private lastEnvText = '';
+  private readonly cachedHostname = getHostnameKey();
+
+  /**
+   * Resolves CLI path with priority: device-specific -> legacy -> auto-detect.
+   * @param settings Full app settings bag
+   */
+  resolveFromSettings(settings: Record<string, unknown>): string | null {
+    const hostnameKey = this.cachedHostname;
+    const claudeSettings = getClaudeProviderSettings(settings);
+
+    const hostnamePath = (claudeSettings.cliPathsByHost[hostnameKey] ?? '').trim();
+    const normalizedLegacy = claudeSettings.cliPath.trim();
+    const normalizedEnv = getRuntimeEnvironmentText(settings, 'claude');
+
+    if (
+      this.resolvedPath &&
+      hostnamePath === this.lastHostnamePath &&
+      normalizedLegacy === this.lastLegacyPath &&
+      normalizedEnv === this.lastEnvText
+    ) {
+      return this.resolvedPath;
+    }
+
+    this.lastHostnamePath = hostnamePath;
+    this.lastLegacyPath = normalizedLegacy;
+    this.lastEnvText = normalizedEnv;
+
+    this.resolvedPath = resolveClaudeCliPath(hostnamePath, normalizedLegacy, normalizedEnv);
+    return this.resolvedPath;
+  }
+
+  resolve(
+    hostnamePaths: HostnameCliPaths | undefined,
+    legacyPath: string | undefined,
+    envText: string,
+  ): string | null {
+    return this.resolveFromSettings({
+      sharedEnvironmentVariables: envText,
+      providerConfigs: {
+        claude: {
+          cliPath: legacyPath ?? '',
+          cliPathsByHost: hostnamePaths ?? {},
+        },
+      },
+    });
+  }
+
+  reset(): void {
+    this.resolvedPath = null;
+    this.lastHostnamePath = '';
+    this.lastLegacyPath = '';
+    this.lastEnvText = '';
+  }
+}
+
+function resolveConfiguredPath(rawPath: string | undefined): string | null {
+  const trimmed = (rawPath ?? '').trim();
+  if (!trimmed) return null;
+  try {
+    const expanded = expandHomePath(trimmed);
+    if (fs.existsSync(expanded) && fs.statSync(expanded).isFile()) {
+      return expanded;
+    }
+  } catch {
+    // Fall through
+  }
+  return null;
+}
+
+export function resolveClaudeCliPath(
+  hostnamePath: string | undefined,
+  legacyPath: string | undefined,
+  envText: string,
+): string | null {
+  return (
+    resolveConfiguredPath(hostnamePath) ??
+    resolveConfiguredPath(legacyPath) ??
+    findClaudeCLIPath(parseEnvironmentVariables(envText || '').PATH)
+  );
+}

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

@@ -0,0 +1,164 @@
+import type {
+  McpServerConfig,
+  PermissionMode as SDKPermissionMode,
+  Query,
+} from '@anthropic-ai/claude-agent-sdk';
+
+import type { McpServerManager } from '../../../core/mcp/McpServerManager';
+import type {
+  ChatRuntimeQueryOptions,
+} from '../../../core/runtime/types';
+import type { ClaudianSettings, PermissionMode } from '../../../core/types/settings';
+import { toClaudeRuntimeModelId } from '../modelSelection';
+import {
+  resolveEffortLevel,
+} from '../types/models';
+import type {
+  ClaudeEnsureReadyOptions,
+  ClosePersistentQueryOptions,
+  PersistentQueryConfig,
+} from './types';
+
+export interface ClaudeDynamicUpdateDeps {
+  getPersistentQuery: () => Query | null;
+  getCurrentConfig: () => PersistentQueryConfig | null;
+  mutateCurrentConfig: (mutate: (config: PersistentQueryConfig) => void) => void;
+  getVaultPath: () => string | null;
+  getCliPath: () => string | null;
+  getScopedSettings: () => ClaudianSettings;
+  getPermissionMode: () => PermissionMode;
+  resolveSDKPermissionMode: (mode: PermissionMode) => SDKPermissionMode;
+  mcpManager: McpServerManager;
+  buildPersistentQueryConfig: (
+    vaultPath: string,
+    cliPath: string,
+    externalContextPaths?: string[],
+  ) => PersistentQueryConfig;
+  needsRestart: (newConfig: PersistentQueryConfig) => boolean;
+  ensureReady: (options: ClaudeEnsureReadyOptions) => Promise<boolean>;
+  setCurrentExternalContextPaths: (paths: string[]) => void;
+  notifyFailure: (message: string) => void;
+}
+
+export async function applyClaudeDynamicUpdates(
+  deps: ClaudeDynamicUpdateDeps,
+  queryOptions?: ChatRuntimeQueryOptions,
+  restartOptions?: ClosePersistentQueryOptions,
+  allowRestart = true,
+): Promise<void> {
+  const persistentQuery = deps.getPersistentQuery();
+  if (!persistentQuery) {
+    return;
+  }
+
+  const vaultPath = deps.getVaultPath();
+  if (!vaultPath) {
+    return;
+  }
+
+  const cliPath = deps.getCliPath();
+  if (!cliPath) {
+    return;
+  }
+
+  const settings = deps.getScopedSettings();
+  const selectedModel = toClaudeRuntimeModelId(queryOptions?.model || settings.model);
+  const permissionMode = deps.getPermissionMode();
+
+  const currentConfig = deps.getCurrentConfig();
+  if (currentConfig && selectedModel !== currentConfig.model) {
+    try {
+      await persistentQuery.setModel(selectedModel);
+      deps.mutateCurrentConfig(config => {
+        config.model = selectedModel;
+      });
+    } catch {
+      deps.notifyFailure('Failed to update model');
+    }
+  }
+
+  const effortLevel = resolveEffortLevel(selectedModel, settings.effortLevel);
+  const currentEffort = deps.getCurrentConfig()?.effortLevel ?? null;
+  if (effortLevel !== currentEffort) {
+    try {
+      // SDK runtime accepts `max`, but the current type definition for
+      // Settings.effortLevel has not caught up yet.
+      await persistentQuery.applyFlagSettings({ effortLevel } as unknown as Parameters<Query['applyFlagSettings']>[0]);
+      deps.mutateCurrentConfig(config => {
+        config.effortLevel = effortLevel;
+      });
+    } catch {
+      deps.notifyFailure('Failed to update effort level');
+    }
+  }
+
+  const configBeforePermissionUpdate = deps.getCurrentConfig();
+  if (configBeforePermissionUpdate) {
+    const sdkMode = deps.resolveSDKPermissionMode(permissionMode);
+    const currentSdkMode = configBeforePermissionUpdate.sdkPermissionMode ?? null;
+    const requiresAutoModeRestart = sdkMode === 'auto' && !configBeforePermissionUpdate.enableAutoMode;
+    if (requiresAutoModeRestart) {
+      // The Claude Code auto-mode opt-in is a startup flag. The restart path below
+      // will rebuild the query with that capability before auto becomes active.
+    } else if (sdkMode !== currentSdkMode) {
+      try {
+        await persistentQuery.setPermissionMode(sdkMode);
+        deps.mutateCurrentConfig(config => {
+          config.permissionMode = permissionMode;
+          config.sdkPermissionMode = sdkMode;
+        });
+      } catch {
+        deps.notifyFailure('Failed to update permission mode');
+      }
+    } else {
+      deps.mutateCurrentConfig(config => {
+        config.permissionMode = permissionMode;
+        config.sdkPermissionMode = sdkMode;
+      });
+    }
+  }
+
+  const mcpMentions = queryOptions?.mcpMentions || new Set<string>();
+  const uiEnabledServers = queryOptions?.enabledMcpServers || new Set<string>();
+  const combinedMentions = new Set([...mcpMentions, ...uiEnabledServers]);
+  const mcpServers = deps.mcpManager.getActiveServers(combinedMentions);
+  const mcpServersKey = JSON.stringify(mcpServers);
+
+  if (deps.getCurrentConfig() && mcpServersKey !== deps.getCurrentConfig()!.mcpServersKey) {
+    const serverConfigs: Record<string, McpServerConfig> = {};
+    for (const [name, config] of Object.entries(mcpServers)) {
+      serverConfigs[name] = config;
+    }
+
+    try {
+      await persistentQuery.setMcpServers(serverConfigs);
+      deps.mutateCurrentConfig(config => {
+        config.mcpServersKey = mcpServersKey;
+      });
+    } catch {
+      deps.notifyFailure('Failed to update MCP servers');
+    }
+  }
+
+  const newExternalContextPaths = queryOptions?.externalContextPaths || [];
+  deps.setCurrentExternalContextPaths(newExternalContextPaths);
+
+  if (!allowRestart) {
+    return;
+  }
+
+  const newConfig = deps.buildPersistentQueryConfig(vaultPath, cliPath, newExternalContextPaths);
+  if (!deps.needsRestart(newConfig)) {
+    return;
+  }
+
+  const restarted = await deps.ensureReady({
+    externalContextPaths: newExternalContextPaths,
+    preserveHandlers: restartOptions?.preserveHandlers,
+    force: true,
+  });
+
+  if (restarted && deps.getPersistentQuery()) {
+    await applyClaudeDynamicUpdates(deps, queryOptions, restartOptions, false);
+  }
+}

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

@@ -0,0 +1,209 @@
+/**
+ * Message Channel
+ *
+ * Queue-based async iterable for persistent queries.
+ * Handles message queuing, turn management, and text merging.
+ */
+
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+
+import {
+  MESSAGE_CHANNEL_CONFIG,
+  type PendingMessage,
+  type PendingTextMessage,
+} from './types';
+
+/**
+ * MessageChannel - Queue-based async iterable for persistent queries.
+ *
+ * Rules:
+ * - Single in-flight turn at a time
+ * - Text-only messages merge with \n\n while a turn is active
+ * - Attachment messages (with images) queue one at a time; newer replaces older while turn is active
+ * - Overflow policy: drop newest and warn
+ */
+export class MessageChannel implements AsyncIterable<SDKUserMessage> {
+  private queue: PendingMessage[] = [];
+  private turnActive = false;
+  private closed = false;
+  private resolveNext: ((value: IteratorResult<SDKUserMessage>) => void) | null = null;
+  private currentSessionId: string | null = null;
+  private onWarning: (message: string) => void;
+
+  constructor(onWarning: (message: string) => void = () => {}) {
+    this.onWarning = onWarning;
+  }
+
+  setSessionId(sessionId: string): void {
+    this.currentSessionId = sessionId;
+  }
+
+  isTurnActive(): boolean {
+    return this.turnActive;
+  }
+
+  isClosed(): boolean {
+    return this.closed;
+  }
+
+  /**
+   * Enqueue a message. If a turn is active:
+   * - Text-only: merge with queued text (up to MAX_MERGED_CHARS)
+   * - With attachments: replace any existing queued attachment (one at a time)
+   */
+  enqueue(message: SDKUserMessage): void {
+    if (this.closed) {
+      throw new Error('MessageChannel is closed');
+    }
+
+    const hasAttachments = this.messageHasAttachments(message);
+
+    if (!this.turnActive) {
+      if (this.resolveNext) {
+        // Consumer is waiting - deliver immediately and mark turn active
+        this.turnActive = true;
+        const resolve = this.resolveNext;
+        this.resolveNext = null;
+        resolve({ value: message, done: false });
+      } else {
+        // No consumer waiting yet - queue for later pickup by next()
+        // Don't set turnActive here; next() will set it when it dequeues
+        if (this.queue.length >= MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES) {
+          this.onWarning(`[MessageChannel] Queue full (${MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES}), dropping newest`);
+          return;
+        }
+        if (hasAttachments) {
+          this.queue.push({ type: 'attachment', message });
+        } else {
+          this.queue.push({ type: 'text', content: this.extractTextContent(message) });
+        }
+      }
+      return;
+    }
+
+    // Turn is active - queue the message
+    if (hasAttachments) {
+      // Non-text messages are deferred as-is (one at a time)
+      // Find existing attachment message or add new one
+      const existingIdx = this.queue.findIndex(m => m.type === 'attachment');
+      if (existingIdx >= 0) {
+        // Replace existing (newer takes precedence for attachments)
+        this.queue[existingIdx] = { type: 'attachment', message };
+        this.onWarning('[MessageChannel] Attachment message replaced (only one can be queued)');
+      } else {
+        this.queue.push({ type: 'attachment', message });
+      }
+      return;
+    }
+
+    // Text-only - merge with existing text in queue
+    const textContent = this.extractTextContent(message);
+    const existingTextIdx = this.queue.findIndex(m => m.type === 'text');
+
+    if (existingTextIdx >= 0) {
+      const existing = this.queue[existingTextIdx] as PendingTextMessage;
+      const mergedContent = existing.content + '\n\n' + textContent;
+
+      // Check merged size
+      if (mergedContent.length > MESSAGE_CHANNEL_CONFIG.MAX_MERGED_CHARS) {
+        this.onWarning(`[MessageChannel] Merged content exceeds ${MESSAGE_CHANNEL_CONFIG.MAX_MERGED_CHARS} chars, dropping newest`);
+        return;
+      }
+
+      existing.content = mergedContent;
+    } else {
+      // No existing text - add new
+      if (this.queue.length >= MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES) {
+        this.onWarning(`[MessageChannel] Queue full (${MESSAGE_CHANNEL_CONFIG.MAX_QUEUED_MESSAGES}), dropping newest`);
+        return;
+      }
+      this.queue.push({ type: 'text', content: textContent });
+    }
+  }
+
+  onTurnComplete(): void {
+    this.turnActive = false;
+
+    if (this.queue.length > 0 && this.resolveNext) {
+      const pending = this.queue.shift()!;
+      this.turnActive = true;
+      const resolve = this.resolveNext;
+      this.resolveNext = null;
+      resolve({ value: this.pendingToMessage(pending), done: false });
+    }
+  }
+
+  close(): void {
+    this.closed = true;
+    this.queue = [];
+    if (this.resolveNext) {
+      const resolve = this.resolveNext;
+      this.resolveNext = null;
+      resolve({ value: undefined, done: true } as IteratorResult<SDKUserMessage>);
+    }
+  }
+
+  reset(): void {
+    this.queue = [];
+    this.turnActive = false;
+    this.closed = false;
+    this.resolveNext = null;
+  }
+
+  getQueueLength(): number {
+    return this.queue.length;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<SDKUserMessage> {
+    return {
+      next: (): Promise<IteratorResult<SDKUserMessage>> => {
+        if (this.closed) {
+          return Promise.resolve({ value: undefined, done: true } as IteratorResult<SDKUserMessage>);
+        }
+
+        // If there's a queued message and no active turn, return it
+        if (this.queue.length > 0 && !this.turnActive) {
+          const pending = this.queue.shift()!;
+          this.turnActive = true;
+          return Promise.resolve({ value: this.pendingToMessage(pending), done: false });
+        }
+
+        // Wait for next message
+        return new Promise((resolve) => {
+          this.resolveNext = resolve;
+        });
+      },
+    };
+  }
+
+  private messageHasAttachments(message: SDKUserMessage): boolean {
+    if (!message.message?.content) return false;
+    if (typeof message.message.content === 'string') return false;
+    return message.message.content.some((block: { type: string }) => block.type === 'image');
+  }
+
+  private extractTextContent(message: SDKUserMessage): string {
+    if (!message.message?.content) return '';
+    if (typeof message.message.content === 'string') return message.message.content;
+    return message.message.content
+      .filter((block: { type: string }): block is { type: 'text'; text: string } => block.type === 'text')
+      .map((block: { type: 'text'; text: string }) => block.text)
+      .join('\n\n');
+  }
+
+  private pendingToMessage(pending: PendingMessage): SDKUserMessage {
+    if (pending.type === 'attachment') {
+      return pending.message;
+    }
+
+    return {
+      type: 'user',
+      message: {
+        role: 'user',
+        content: pending.content,
+      },
+      parent_tool_use_id: null,
+      session_id: this.currentSessionId || '',
+    };
+  }
+}