@mseep/claudian 2.0.25

package/src/providers/claude/security/ClaudePermissionUpdates.ts

@@ -0,0 +1,44 @@
+import type { PermissionUpdate, PermissionUpdateDestination } from '@anthropic-ai/claude-agent-sdk';
+
+import { getActionPattern } from '../../../core/security/ApprovalManager';
+
+export function buildPermissionUpdates(
+  toolName: string,
+  input: Record<string, unknown>,
+  decision: 'allow' | 'allow-always',
+  suggestions?: PermissionUpdate[]
+): PermissionUpdate[] {
+  const destination: PermissionUpdateDestination =
+    decision === 'allow-always' ? 'projectSettings' : 'session';
+
+  const processed: PermissionUpdate[] = [];
+  let hasRuleUpdate = false;
+
+  if (suggestions) {
+    for (const suggestion of suggestions) {
+      if (suggestion.type === 'addRules' || suggestion.type === 'replaceRules') {
+        hasRuleUpdate = true;
+        processed.push({ ...suggestion, behavior: 'allow', destination });
+      } else {
+        processed.push(suggestion);
+      }
+    }
+  }
+
+  if (!hasRuleUpdate) {
+    const pattern = getActionPattern(toolName, input);
+    const ruleValue: { toolName: string; ruleContent?: string } = { toolName };
+    if (pattern && !pattern.startsWith('{')) {
+      ruleValue.ruleContent = pattern;
+    }
+
+    processed.unshift({
+      type: 'addRules',
+      behavior: 'allow',
+      rules: [ruleValue],
+      destination,
+    });
+  }
+
+  return processed;
+}

package/src/providers/claude/settings.ts

@@ -0,0 +1,138 @@
+import { getProviderConfig, setProviderConfig } from '../../core/providers/providerConfig';
+import { getProviderEnvironmentVariables } from '../../core/providers/providerEnvironment';
+import type { HostnameCliPaths } from '../../core/types/settings';
+import {
+  getHostnameKey,
+  getLegacyHostnameKey,
+  migrateLegacyHostnameKeyedMap,
+} from '../../utils/env';
+
+export const CLAUDE_SAFE_MODES = ['acceptEdits', 'auto', 'default'] as const;
+export type ClaudeSafeMode = typeof CLAUDE_SAFE_MODES[number];
+export type ClaudeSettingSource = 'user' | 'project' | 'local';
+
+export interface ClaudeProviderSettings {
+  safeMode: ClaudeSafeMode;
+  cliPath: string;
+  cliPathsByHost: HostnameCliPaths;
+  loadUserSettings: boolean;
+  enableChrome: boolean;
+  enableBangBash: boolean;
+  enableOpus1M: boolean;
+  enableSonnet1M: boolean;
+  customModels: string;
+  lastModel: string;
+  environmentVariables: string;
+  environmentHash: string;
+}
+
+export const DEFAULT_CLAUDE_PROVIDER_SETTINGS: Readonly<ClaudeProviderSettings> = Object.freeze({
+  safeMode: 'acceptEdits',
+  cliPath: '',
+  cliPathsByHost: {},
+  loadUserSettings: true,
+  enableChrome: false,
+  enableBangBash: false,
+  enableOpus1M: false,
+  enableSonnet1M: false,
+  customModels: '',
+  lastModel: 'haiku',
+  environmentVariables: '',
+  environmentHash: '',
+});
+
+function normalizeHostnameCliPaths(value: unknown): HostnameCliPaths {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+
+  const result: HostnameCliPaths = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === 'string' && entry.trim()) {
+      result[key] = entry.trim();
+    }
+  }
+  return result;
+}
+
+function normalizeClaudeSafeMode(value: unknown): ClaudeSafeMode | undefined {
+  return (CLAUDE_SAFE_MODES as readonly unknown[]).includes(value)
+    ? value as ClaudeSafeMode
+    : undefined;
+}
+
+export function getClaudeProviderSettings(
+  settings: Record<string, unknown>,
+): ClaudeProviderSettings {
+  const config = getProviderConfig(settings, 'claude');
+  const normalizedCliPathsByHost = normalizeHostnameCliPaths(
+    config.cliPathsByHost ?? settings.claudeCliPathsByHost,
+  );
+  const cliPathsByHost = Object.keys(normalizedCliPathsByHost).length > 0
+    ? migrateLegacyHostnameKeyedMap(
+      normalizedCliPathsByHost,
+      getHostnameKey(),
+      getLegacyHostnameKey(),
+    )
+    : normalizedCliPathsByHost;
+
+  return {
+    safeMode: normalizeClaudeSafeMode(config.safeMode)
+      ?? normalizeClaudeSafeMode(settings.claudeSafeMode)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.safeMode,
+    cliPath: (config.cliPath as string | undefined)
+      ?? (settings.claudeCliPath as string | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.cliPath,
+    cliPathsByHost,
+    loadUserSettings: (config.loadUserSettings as boolean | undefined)
+      ?? (settings.loadUserClaudeSettings as boolean | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.loadUserSettings,
+    enableChrome: (config.enableChrome as boolean | undefined)
+      ?? (settings.enableChrome as boolean | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableChrome,
+    enableBangBash: (config.enableBangBash as boolean | undefined)
+      ?? (settings.enableBangBash as boolean | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableBangBash,
+    enableOpus1M: (config.enableOpus1M as boolean | undefined)
+      ?? (settings.enableOpus1M as boolean | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableOpus1M,
+    enableSonnet1M: (config.enableSonnet1M as boolean | undefined)
+      ?? (settings.enableSonnet1M as boolean | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.enableSonnet1M,
+    customModels: (config.customModels as string | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.customModels,
+    lastModel: (config.lastModel as string | undefined)
+      ?? (settings.lastClaudeModel as string | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.lastModel,
+    environmentVariables: (config.environmentVariables as string | undefined)
+      ?? getProviderEnvironmentVariables(settings, 'claude')
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.environmentVariables,
+    environmentHash: (config.environmentHash as string | undefined)
+      ?? (settings.lastEnvHash as string | undefined)
+      ?? DEFAULT_CLAUDE_PROVIDER_SETTINGS.environmentHash,
+  };
+}
+
+export function resolveClaudeSettingSources(
+  loadUserSettings: boolean,
+): ClaudeSettingSource[] {
+  return loadUserSettings
+    ? ['user', 'project', 'local']
+    : ['project', 'local'];
+}
+
+export function updateClaudeProviderSettings(
+  settings: Record<string, unknown>,
+  updates: Partial<ClaudeProviderSettings>,
+): ClaudeProviderSettings {
+  const current = getClaudeProviderSettings(settings);
+  const next = {
+    ...current,
+    ...updates,
+    safeMode: 'safeMode' in updates
+      ? normalizeClaudeSafeMode(updates.safeMode) ?? current.safeMode
+      : current.safeMode,
+  };
+  setProviderConfig(settings, 'claude', next);
+  return next;
+}

package/src/providers/claude/storage/AgentVaultStorage.ts

@@ -0,0 +1,101 @@
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import type { AgentDefinition } from '../../../core/types';
+import { serializeAgent } from '../../../utils/agent';
+import { buildAgentFromFrontmatter, parseAgentFile } from '../agents/AgentStorage';
+
+export const AGENTS_PATH = '.claude/agents';
+
+export class AgentVaultStorage {
+  constructor(private adapter: VaultFileAdapter) {}
+
+  async loadAll(): Promise<AgentDefinition[]> {
+    const agents: AgentDefinition[] = [];
+
+    try {
+      const files = await this.adapter.listFiles(AGENTS_PATH);
+
+      for (const filePath of files) {
+        if (!filePath.endsWith('.md')) continue;
+
+        try {
+          const content = await this.adapter.read(filePath);
+          const parsed = parseAgentFile(content);
+          if (!parsed) continue;
+
+          const { frontmatter, body } = parsed;
+
+          agents.push(buildAgentFromFrontmatter(frontmatter, body, {
+            id: frontmatter.name,
+            source: 'vault',
+            filePath,
+          }));
+        } catch { /* Non-critical: skip malformed agent files */ }
+      }
+    } catch { /* Non-critical: directory may not exist yet */ }
+
+    return agents;
+  }
+
+  async load(agent: AgentDefinition): Promise<AgentDefinition | null> {
+    const filePath = this.resolvePath(agent);
+    try {
+      const content = await this.adapter.read(filePath);
+      const parsed = parseAgentFile(content);
+      if (!parsed) return null;
+      const { frontmatter, body } = parsed;
+      return buildAgentFromFrontmatter(frontmatter, body, {
+        id: frontmatter.name,
+        source: agent.source,
+        filePath,
+      });
+    } catch (error) {
+      if (this.isFileNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async save(agent: AgentDefinition): Promise<void> {
+    await this.adapter.write(this.resolvePath(agent), serializeAgent(agent));
+  }
+
+  async delete(agent: AgentDefinition): Promise<void> {
+    await this.adapter.delete(this.resolvePath(agent));
+  }
+
+  private resolvePath(agent: AgentDefinition): string {
+    if (!agent.filePath) {
+      return `${AGENTS_PATH}/${agent.name}.md`;
+    }
+
+    const normalized = agent.filePath.replace(/\\/g, '/');
+    const idx = normalized.lastIndexOf(`${AGENTS_PATH}/`);
+    if (idx !== -1) {
+      return normalized.slice(idx);
+    }
+    return `${AGENTS_PATH}/${agent.name}.md`;
+  }
+
+  private isFileNotFoundError(error: unknown): boolean {
+    if (!error) return false;
+
+    if (typeof error === 'string') {
+      return /enoent|not found|no such file/i.test(error);
+    }
+
+    if (typeof error === 'object') {
+      const maybeCode = (error as { code?: unknown }).code;
+      if (typeof maybeCode === 'string' && /enoent|not.?found/i.test(maybeCode)) {
+        return true;
+      }
+
+      const maybeMessage = (error as { message?: unknown }).message;
+      if (typeof maybeMessage === 'string' && /enoent|not found|no such file/i.test(maybeMessage)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/src/providers/claude/storage/CCSettingsStorage.ts

@@ -0,0 +1,153 @@
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import type {
+  CCPermissions,
+  CCSettings,
+  PermissionRule,
+} from '../types/settings';
+import { DEFAULT_CC_PERMISSIONS, DEFAULT_CC_SETTINGS } from '../types/settings';
+
+export const CC_SETTINGS_PATH = '.claude/settings.json';
+
+const CC_SETTINGS_SCHEMA = 'https://json.schemastore.org/claude-code-settings.json';
+
+function normalizeRuleList(value: unknown): PermissionRule[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((r): r is string => typeof r === 'string') as PermissionRule[];
+}
+
+function normalizePermissions(permissions: unknown): CCPermissions {
+  if (!permissions || typeof permissions !== 'object') {
+    return { ...DEFAULT_CC_PERMISSIONS };
+  }
+
+  const p = permissions as Record<string, unknown>;
+  return {
+    allow: normalizeRuleList(p.allow),
+    deny: normalizeRuleList(p.deny),
+    ask: normalizeRuleList(p.ask),
+    defaultMode: typeof p.defaultMode === 'string' ? p.defaultMode as CCPermissions['defaultMode'] : undefined,
+    additionalDirectories: Array.isArray(p.additionalDirectories)
+      ? p.additionalDirectories.filter((d): d is string => typeof d === 'string')
+      : undefined,
+  };
+}
+
+export class CCSettingsStorage {
+  constructor(private adapter: VaultFileAdapter) { }
+
+  async load(): Promise<CCSettings> {
+    if (!(await this.adapter.exists(CC_SETTINGS_PATH))) {
+      return { ...DEFAULT_CC_SETTINGS };
+    }
+
+    const content = await this.adapter.read(CC_SETTINGS_PATH);
+    const stored = JSON.parse(content) as Record<string, unknown>;
+
+    return {
+      $schema: CC_SETTINGS_SCHEMA,
+      ...stored,
+      permissions: normalizePermissions(stored.permissions),
+    };
+  }
+
+  async save(settings: CCSettings): Promise<void> {
+    // Preserve CC-specific fields we don't manage
+    let existing: Record<string, unknown> = {};
+    if (await this.adapter.exists(CC_SETTINGS_PATH)) {
+      try {
+        const content = await this.adapter.read(CC_SETTINGS_PATH);
+        existing = JSON.parse(content) as Record<string, unknown>;
+      } catch {
+        // Parse error - start fresh with default settings
+      }
+    }
+
+    // Merge: existing CC fields + our updates
+    const merged: CCSettings = {
+      ...existing,
+      $schema: CC_SETTINGS_SCHEMA,
+      permissions: settings.permissions ?? { ...DEFAULT_CC_PERMISSIONS },
+    };
+
+    if (settings.enabledPlugins !== undefined) {
+      merged.enabledPlugins = settings.enabledPlugins;
+    }
+
+    const content = JSON.stringify(merged, null, 2);
+    await this.adapter.write(CC_SETTINGS_PATH, content);
+  }
+
+  async exists(): Promise<boolean> {
+    return this.adapter.exists(CC_SETTINGS_PATH);
+  }
+
+  async getPermissions(): Promise<CCPermissions> {
+    const settings = await this.load();
+    return settings.permissions ?? { ...DEFAULT_CC_PERMISSIONS };
+  }
+
+  async updatePermissions(permissions: CCPermissions): Promise<void> {
+    const settings = await this.load();
+    settings.permissions = permissions;
+    await this.save(settings);
+  }
+
+  async addAllowRule(rule: PermissionRule): Promise<void> {
+    const permissions = await this.getPermissions();
+    if (!permissions.allow?.includes(rule)) {
+      permissions.allow = [...(permissions.allow ?? []), rule];
+      await this.updatePermissions(permissions);
+    }
+  }
+
+  async addDenyRule(rule: PermissionRule): Promise<void> {
+    const permissions = await this.getPermissions();
+    if (!permissions.deny?.includes(rule)) {
+      permissions.deny = [...(permissions.deny ?? []), rule];
+      await this.updatePermissions(permissions);
+    }
+  }
+
+  async addAskRule(rule: PermissionRule): Promise<void> {
+    const permissions = await this.getPermissions();
+    if (!permissions.ask?.includes(rule)) {
+      permissions.ask = [...(permissions.ask ?? []), rule];
+      await this.updatePermissions(permissions);
+    }
+  }
+
+  async removeRule(rule: PermissionRule): Promise<void> {
+    const permissions = await this.getPermissions();
+    permissions.allow = permissions.allow?.filter(r => r !== rule);
+    permissions.deny = permissions.deny?.filter(r => r !== rule);
+    permissions.ask = permissions.ask?.filter(r => r !== rule);
+    await this.updatePermissions(permissions);
+  }
+
+  async getEnabledPlugins(): Promise<Record<string, boolean>> {
+    const settings = await this.load();
+    return settings.enabledPlugins ?? {};
+  }
+
+  async setPluginEnabled(pluginId: string, enabled: boolean): Promise<void> {
+    const settings = await this.load();
+    const enabledPlugins = settings.enabledPlugins ?? {};
+
+    enabledPlugins[pluginId] = enabled;
+    settings.enabledPlugins = enabledPlugins;
+
+    await this.save(settings);
+  }
+
+  async getExplicitlyEnabledPluginIds(): Promise<string[]> {
+    const enabledPlugins = await this.getEnabledPlugins();
+    return Object.entries(enabledPlugins)
+      .filter(([, enabled]) => enabled)
+      .map(([id]) => id);
+  }
+
+  async isPluginDisabled(pluginId: string): Promise<boolean> {
+    const enabledPlugins = await this.getEnabledPlugins();
+    return enabledPlugins[pluginId] === false;
+  }
+}

package/src/providers/claude/storage/ClaudianSettingsStorage.ts

@@ -0,0 +1,6 @@
+export {
+  CLAUDIAN_SETTINGS_PATH,
+  ClaudianSettingsStorage,
+  LEGACY_CLAUDIAN_SETTINGS_PATH,
+  type StoredClaudianSettings,
+} from '../../../app/settings/ClaudianSettingsStorage';

package/src/providers/claude/storage/McpStorage.ts

@@ -0,0 +1,139 @@
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import type {
+  ManagedMcpConfigFile,
+  ManagedMcpServer,
+  McpServerConfig,
+} from '../../../core/types';
+import { DEFAULT_MCP_SERVER, isValidMcpServerConfig } from '../../../core/types';
+
+export const MCP_CONFIG_PATH = '.claude/mcp.json';
+
+export class McpStorage {
+  constructor(private adapter: VaultFileAdapter) {}
+
+  async load(): Promise<ManagedMcpServer[]> {
+    try {
+      if (!(await this.adapter.exists(MCP_CONFIG_PATH))) {
+        return [];
+      }
+
+      const content = await this.adapter.read(MCP_CONFIG_PATH);
+      const file = JSON.parse(content) as ManagedMcpConfigFile;
+
+      if (!file.mcpServers || typeof file.mcpServers !== 'object') {
+        return [];
+      }
+
+      const claudianMeta = file._claudian?.servers ?? {};
+      const servers: ManagedMcpServer[] = [];
+
+      for (const [name, config] of Object.entries(file.mcpServers)) {
+        if (!isValidMcpServerConfig(config)) {
+          continue;
+        }
+
+        const meta = claudianMeta[name] ?? {};
+        const disabledTools = Array.isArray(meta.disabledTools)
+          ? meta.disabledTools.filter((tool) => typeof tool === 'string')
+          : undefined;
+        const normalizedDisabledTools =
+          disabledTools && disabledTools.length > 0 ? disabledTools : undefined;
+
+        servers.push({
+          name,
+          config,
+          enabled: meta.enabled ?? DEFAULT_MCP_SERVER.enabled,
+          contextSaving: meta.contextSaving ?? DEFAULT_MCP_SERVER.contextSaving,
+          disabledTools: normalizedDisabledTools,
+          description: meta.description,
+        });
+      }
+
+      return servers;
+    } catch {
+      return [];
+    }
+  }
+
+  async save(servers: ManagedMcpServer[]): Promise<void> {
+    const mcpServers: Record<string, McpServerConfig> = {};
+    const claudianServers: Record<
+      string,
+      { enabled?: boolean; contextSaving?: boolean; disabledTools?: string[]; description?: string }
+    > = {};
+
+    for (const server of servers) {
+      mcpServers[server.name] = server.config;
+
+      // Only store Claudian metadata if different from defaults
+      const meta: {
+        enabled?: boolean;
+        contextSaving?: boolean;
+        disabledTools?: string[];
+        description?: string;
+      } = {};
+
+      if (server.enabled !== DEFAULT_MCP_SERVER.enabled) {
+        meta.enabled = server.enabled;
+      }
+      if (server.contextSaving !== DEFAULT_MCP_SERVER.contextSaving) {
+        meta.contextSaving = server.contextSaving;
+      }
+      const normalizedDisabledTools = server.disabledTools
+        ?.map((tool) => tool.trim())
+        .filter((tool) => tool.length > 0);
+      if (normalizedDisabledTools && normalizedDisabledTools.length > 0) {
+        meta.disabledTools = normalizedDisabledTools;
+      }
+      if (server.description) {
+        meta.description = server.description;
+      }
+
+      if (Object.keys(meta).length > 0) {
+        claudianServers[server.name] = meta;
+      }
+    }
+
+    let existing: Record<string, unknown> | null = null;
+    if (await this.adapter.exists(MCP_CONFIG_PATH)) {
+      try {
+        const raw = await this.adapter.read(MCP_CONFIG_PATH);
+        const parsed: unknown = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+          existing = parsed as Record<string, unknown>;
+        }
+      } catch {
+        existing = null;
+      }
+    }
+
+    const file: Record<string, unknown> = existing ? { ...existing } : {};
+    file.mcpServers = mcpServers;
+
+    const existingClaudian =
+      existing && typeof existing._claudian === 'object'
+        ? (existing._claudian as Record<string, unknown>)
+        : null;
+
+    if (Object.keys(claudianServers).length > 0) {
+      file._claudian = { ...(existingClaudian ?? {}), servers: claudianServers };
+    } else if (existingClaudian) {
+      const rest = { ...existingClaudian };
+      delete rest.servers;
+      if (Object.keys(rest).length > 0) {
+        file._claudian = rest;
+      } else {
+        delete file._claudian;
+      }
+    } else {
+      delete file._claudian;
+    }
+
+    const content = JSON.stringify(file, null, 2);
+    await this.adapter.write(MCP_CONFIG_PATH, content);
+  }
+
+  async exists(): Promise<boolean> {
+    return this.adapter.exists(MCP_CONFIG_PATH);
+  }
+}

package/src/providers/claude/storage/SessionStorage.ts

@@ -0,0 +1,5 @@
+export {
+  LEGACY_SESSIONS_PATH,
+  SESSIONS_PATH,
+  SessionStorage,
+} from '../../../core/bootstrap/SessionStorage';

package/src/providers/claude/storage/SkillStorage.ts

@@ -0,0 +1,61 @@
+import type { VaultFileAdapter } from '../../../core/storage/VaultFileAdapter';
+import type { SlashCommand } from '../../../core/types';
+import { parsedToSlashCommand, parseSlashCommandContent, serializeCommand } from '../../../utils/slashCommand';
+
+export const SKILLS_PATH = '.claude/skills';
+
+export class SkillStorage {
+  constructor(private adapter: VaultFileAdapter) {}
+
+  async loadAll(): Promise<SlashCommand[]> {
+    const skills: SlashCommand[] = [];
+
+    try {
+      const folders = await this.adapter.listFolders(SKILLS_PATH);
+
+      for (const folder of folders) {
+        const skillName = folder.split('/').pop()!;
+        const skillPath = `${SKILLS_PATH}/${skillName}/SKILL.md`;
+
+        try {
+          if (!(await this.adapter.exists(skillPath))) continue;
+
+          const content = await this.adapter.read(skillPath);
+          const parsed = parseSlashCommandContent(content);
+
+          skills.push({
+            ...parsedToSlashCommand(parsed, {
+              id: `skill-${skillName}`,
+              name: skillName,
+              source: 'user',
+            }),
+            kind: 'skill',
+          });
+        } catch {
+          // Non-critical: skip malformed skill files
+        }
+      }
+    } catch {
+      return [];
+    }
+
+    return skills;
+  }
+
+  async save(skill: SlashCommand): Promise<void> {
+    const name = skill.name;
+    const dirPath = `${SKILLS_PATH}/${name}`;
+    const filePath = `${dirPath}/SKILL.md`;
+
+    await this.adapter.ensureFolder(dirPath);
+    await this.adapter.write(filePath, serializeCommand(skill));
+  }
+
+  async delete(skillId: string): Promise<void> {
+    const name = skillId.replace(/^skill-/, '');
+    const dirPath = `${SKILLS_PATH}/${name}`;
+    const filePath = `${dirPath}/SKILL.md`;
+    await this.adapter.delete(filePath);
+    await this.adapter.deleteFolder(dirPath);
+  }
+}