ashlrcode 1.0.0 → 2.1.0

package/src/mcp/manager.ts

@@ -3,13 +3,21 @@
  */
 
 import chalk from "chalk";
-import { MCPClient } from "./client.ts";
+import { MCPClient, MCPSSEClient, MCPWebSocketClient, createMCPClient } from "./client.ts";
 import type { MCPServerConfig, MCPToolInfo } from "./types.ts";
 import { authorizeOAuth } from "./oauth.ts";
 import type { OAuthConfig } from "./oauth.ts";
 
+type MCPClientType = MCPClient | MCPSSEClient | MCPWebSocketClient;
+
+export type MCPConnectionState = "connected" | "disconnected" | "reconnecting";
+
 export class MCPManager {
-  private clients = new Map<string, MCPClient>();
+  private clients = new Map<string, MCPClientType>();
+  private configs = new Map<string, MCPServerConfig>();
+  /** Original configs (pre-OAuth) for token refresh on reconnect */
+  private originalConfigs = new Map<string, MCPServerConfig>();
+  private connectionStates = new Map<string, MCPConnectionState>();
 
   /**
    * Connect to all configured MCP servers.
@@ -50,17 +58,22 @@ export class MCPManager {
           }
         }
 
-        const client = new MCPClient(name, effectiveConfig);
+        this.originalConfigs.set(name, config);
+        this.configs.set(name, effectiveConfig);
+        const client = createMCPClient(name, effectiveConfig);
         try {
           await client.connect();
           this.clients.set(name, client);
+          this.connectionStates.set(name, "connected");
           console.log(
             chalk.dim(
               `  MCP: ${name} connected (${client.tools.length} tools)`
             )
           );
-        } catch {
-          // Silently skip failed MCP servers — they may not be running
+        } catch (err) {
+          this.connectionStates.set(name, "disconnected");
+          const msg = err instanceof Error ? err.message : String(err);
+          console.log(chalk.yellow(`  MCP: ${name} failed to connect — ${msg.slice(0, 100)}`));
         }
       })
     );
@@ -81,6 +94,7 @@ export class MCPManager {
 
   /**
    * Call a tool on a specific server.
+   * On connection error, attempts one reconnect before failing.
    */
   async callTool(
     serverName: string,
@@ -92,18 +106,120 @@ export class MCPManager {
       return `MCP server "${serverName}" not connected`;
     }
 
-    const result = await client.callTool(toolName, args);
+    try {
+      const result = await client.callTool(toolName, args);
+
+      // Extract text from result content blocks
+      const text = result.content
+        .map((c) => c.text ?? JSON.stringify(c))
+        .join("\n");
+
+      if (result.isError) {
+        return `MCP Error: ${text}`;
+      }
+
+      return text;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isConnectionError =
+        msg.includes("connection closed") ||
+        msg.includes("not connected") ||
+        msg.includes("disconnected") ||
+        msg.includes("stream ended") ||
+        msg.includes("WebSocket connection closed") ||
+        msg.includes("WebSocket not connected");
+
+      if (!isConnectionError) {
+        return `MCP Error: ${msg}`;
+      }
+
+      // Attempt one reconnect
+      console.log(chalk.dim(`  MCP: ${serverName} connection lost, attempting reconnect...`));
+      const reconnected = await this.reconnect(serverName);
+      if (!reconnected) {
+        return `MCP server "${serverName}" disconnected and reconnect failed`;
+      }
+
+      // Retry the tool call after successful reconnect
+      try {
+        const retryClient = this.clients.get(serverName);
+        if (!retryClient) return `MCP server "${serverName}" not connected after reconnect`;
+        const result = await retryClient.callTool(toolName, args);
+        const text = result.content
+          .map((c) => c.text ?? JSON.stringify(c))
+          .join("\n");
+        if (result.isError) return `MCP Error: ${text}`;
+        return text;
+      } catch (retryErr) {
+        const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+        return `MCP Error (after reconnect): ${retryMsg}`;
+      }
+    }
+  }
+
+  /**
+   * Reconnect to a specific MCP server.
+   * Returns true if reconnection succeeded, false otherwise.
+   */
+  async reconnect(serverName: string): Promise<boolean> {
+    const originalConfig = this.originalConfigs.get(serverName);
+    if (!originalConfig) {
+      console.log(chalk.yellow(`  MCP: ${serverName} — no config found for reconnect`));
+      return false;
+    }
 
-    // Extract text from result content blocks
-    const text = result.content
-      .map((c) => c.text ?? JSON.stringify(c))
-      .join("\n");
+    this.connectionStates.set(serverName, "reconnecting");
 
-    if (result.isError) {
-      return `MCP Error: ${text}`;
+    // Disconnect existing client if any
+    const existing = this.clients.get(serverName);
+    if (existing) {
+      try { await existing.disconnect(); } catch { /* ignore */ }
+      this.clients.delete(serverName);
     }
 
-    return text;
+    // Re-do OAuth if the original config had it (token may have expired)
+    let effectiveConfig = originalConfig;
+    if (originalConfig.oauth) {
+      try {
+        const oauthConfig: OAuthConfig = {
+          ...originalConfig.oauth,
+          scopes: originalConfig.oauth.scopes ?? [],
+        };
+        const token = await authorizeOAuth(serverName, oauthConfig);
+        effectiveConfig = {
+          ...originalConfig,
+          env: {
+            ...originalConfig.env,
+            MCP_AUTH_TOKEN: token.accessToken,
+            MCP_AUTH_TYPE: token.tokenType,
+          },
+        };
+      } catch {
+        console.log(chalk.yellow(`  MCP: ${serverName} OAuth refresh failed during reconnect`));
+      }
+    }
+
+    try {
+      this.configs.set(serverName, effectiveConfig);
+      const client = createMCPClient(serverName, effectiveConfig);
+      await client.connect();
+      this.clients.set(serverName, client);
+      this.connectionStates.set(serverName, "connected");
+      console.log(chalk.dim(`  MCP: ${serverName} reconnected (${client.tools.length} tools)`));
+      return true;
+    } catch (err) {
+      this.connectionStates.set(serverName, "disconnected");
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.yellow(`  MCP: ${serverName} reconnect failed — ${msg.slice(0, 100)}`));
+      return false;
+    }
+  }
+
+  /**
+   * Get the connection state for a server.
+   */
+  getConnectionState(serverName: string): MCPConnectionState {
+    return this.connectionStates.get(serverName) ?? "disconnected";
   }
 
   /**

package/src/mcp/types.ts

@@ -3,9 +3,12 @@
  */
 
 export interface MCPServerConfig {
-  command: string;
+  /** stdio transport: command to spawn */
+  command?: string;
   args?: string[];
   env?: Record<string, string>;
+  /** SSE transport: URL of MCP server (e.g. http://localhost:3000) */
+  url?: string;
   oauth?: {
     authorizationUrl: string;
     tokenUrl: string;

package/src/migrate.ts

@@ -0,0 +1,228 @@
+/**
+ * Migrate from Claude Code — one-time config copy.
+ *
+ * Reads ~/.claude/settings.json and copies:
+ * - MCP server configurations
+ * - Permission rules (converted to AshlrCode format)
+ * - Custom slash commands / skills
+ *
+ * Does NOT copy: sessions (different format), API keys (different providers),
+ * or settings that don't apply (model names, IDE extensions, etc.)
+ *
+ * Usage: ac --migrate
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir, readdir, copyFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+import { getConfigDir, loadSettings, saveSettings, type Settings } from "./config/settings.ts";
+
+const CLAUDE_DIR = join(homedir(), ".claude");
+const CLAUDE_SETTINGS = join(CLAUDE_DIR, "settings.json");
+const CLAUDE_COMMANDS_DIR = join(CLAUDE_DIR, "commands");
+
+interface ClaudeSettings {
+  mcpServers?: Record<string, {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    // Claude Code may have additional fields we don't need
+    [key: string]: unknown;
+  }>;
+  permissions?: {
+    allow?: string[];
+    deny?: string[];
+  };
+  hooks?: {
+    preToolUse?: Array<{
+      matcher?: string;
+      command?: string;
+      [key: string]: unknown;
+    }>;
+  };
+  [key: string]: unknown;
+}
+
+export async function runMigration(): Promise<void> {
+  console.log(chalk.cyan("\n  🔄 AshlrCode Migration from Claude Code\n"));
+
+  // Check Claude Code config exists
+  if (!existsSync(CLAUDE_DIR)) {
+    console.log(chalk.yellow("  ~/.claude/ directory not found."));
+    console.log(chalk.dim("  Make sure Claude Code is installed and has been run at least once.\n"));
+    process.exit(1);
+  }
+
+  // Load existing AshlrCode settings (or defaults)
+  const acSettings = await loadSettings();
+  let changesMade = false;
+
+  // ── Step 1: Migrate MCP Servers ──────────────────────────────
+  if (existsSync(CLAUDE_SETTINGS)) {
+    console.log(chalk.white("  Reading ~/.claude/settings.json..."));
+    try {
+      const raw = await readFile(CLAUDE_SETTINGS, "utf-8");
+      const claudeSettings = JSON.parse(raw) as ClaudeSettings;
+
+      // Also check project-level settings
+      const projectSettingsPath = join(CLAUDE_DIR, "settings.local.json");
+      let projectSettings: ClaudeSettings = {};
+      if (existsSync(projectSettingsPath)) {
+        try {
+          projectSettings = JSON.parse(await readFile(projectSettingsPath, "utf-8")) as ClaudeSettings;
+        } catch { /* ignore */ }
+      }
+
+      // Merge MCP servers from both global and project settings
+      const allMcpServers = {
+        ...claudeSettings.mcpServers,
+        ...projectSettings.mcpServers,
+      };
+
+      if (Object.keys(allMcpServers).length > 0) {
+        acSettings.mcpServers = acSettings.mcpServers ?? {};
+
+        let migrated = 0;
+        let skipped = 0;
+
+        for (const [name, config] of Object.entries(allMcpServers)) {
+          if (acSettings.mcpServers[name]) {
+            console.log(chalk.dim(`    ⊘ ${name} — already exists, skipping`));
+            skipped++;
+            continue;
+          }
+
+          // Convert to AshlrCode MCPServerConfig format
+          // We only copy fields our config supports
+          const acConfig: Record<string, unknown> = {};
+          if (config.command) acConfig.command = config.command;
+          if (config.args) acConfig.args = config.args;
+          if (config.env) acConfig.env = config.env;
+          if (config.url) acConfig.url = config.url;
+
+          acSettings.mcpServers[name] = acConfig as any;
+          console.log(chalk.green(`    ✓ ${name} — migrated (${config.command ? "stdio" : config.url ? "SSE" : "unknown transport"})`));
+          migrated++;
+        }
+
+        if (migrated > 0) {
+          changesMade = true;
+          console.log(chalk.cyan(`\n  MCP: ${migrated} servers migrated, ${skipped} skipped\n`));
+        } else {
+          console.log(chalk.dim(`\n  MCP: All ${skipped} servers already exist\n`));
+        }
+      } else {
+        console.log(chalk.dim("  No MCP servers found in Claude Code config\n"));
+      }
+
+      // ── Step 2: Migrate Permission Rules ──────────────────────
+      const claudePerms = claudeSettings.permissions;
+      if (claudePerms) {
+        acSettings.permissionRules = acSettings.permissionRules ?? [];
+        let permsMigrated = 0;
+
+        if (claudePerms.allow) {
+          for (const pattern of claudePerms.allow) {
+            // Claude Code allow rules are tool name patterns
+            const exists = acSettings.permissionRules.some(
+              (r) => r.tool === pattern && r.action === "allow"
+            );
+            if (!exists) {
+              acSettings.permissionRules.push({ tool: pattern, action: "allow" });
+              console.log(chalk.green(`    ✓ Allow rule: ${pattern}`));
+              permsMigrated++;
+            }
+          }
+        }
+
+        if (claudePerms.deny) {
+          for (const pattern of claudePerms.deny) {
+            const exists = acSettings.permissionRules.some(
+              (r) => r.tool === pattern && r.action === "deny"
+            );
+            if (!exists) {
+              acSettings.permissionRules.push({ tool: pattern, action: "deny" });
+              console.log(chalk.green(`    ✓ Deny rule: ${pattern}`));
+              permsMigrated++;
+            }
+          }
+        }
+
+        if (permsMigrated > 0) {
+          changesMade = true;
+          console.log(chalk.cyan(`\n  Permissions: ${permsMigrated} rules migrated\n`));
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.red(`  Failed to read Claude Code settings: ${msg}\n`));
+    }
+  } else {
+    console.log(chalk.dim("  No ~/.claude/settings.json found\n"));
+  }
+
+  // ── Step 3: Migrate Custom Commands → Skills ──────────────
+  if (existsSync(CLAUDE_COMMANDS_DIR)) {
+    const skillsDir = join(getConfigDir(), "skills");
+    await mkdir(skillsDir, { recursive: true });
+
+    try {
+      const files = await readdir(CLAUDE_COMMANDS_DIR);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      let skillsMigrated = 0;
+
+      for (const file of mdFiles) {
+        const destPath = join(skillsDir, file);
+        if (existsSync(destPath)) {
+          console.log(chalk.dim(`    ⊘ ${file} — already exists, skipping`));
+          continue;
+        }
+
+        const content = await readFile(join(CLAUDE_COMMANDS_DIR, file), "utf-8");
+
+        // Convert Claude Code command format to AshlrCode skill format
+        // Claude uses $ARGUMENTS, AshlrCode uses {{args}}
+        let converted = content.replace(/\$ARGUMENTS/g, "{{args}}");
+        converted = converted.replace(/\$arguments/g, "{{args}}");
+
+        // If the file has no frontmatter, add basic frontmatter
+        if (!converted.startsWith("---")) {
+          const name = file.replace(".md", "");
+          converted = `---\nname: ${name}\ndescription: Migrated from Claude Code\ntrigger: /${name}\n---\n\n${converted}`;
+        }
+
+        await writeFile(destPath, converted, "utf-8");
+        console.log(chalk.green(`    ✓ ${file} → skills/${file}`));
+        skillsMigrated++;
+        changesMade = true;
+      }
+
+      if (skillsMigrated > 0) {
+        console.log(chalk.cyan(`\n  Skills: ${skillsMigrated} commands migrated\n`));
+      } else if (mdFiles.length > 0) {
+        console.log(chalk.dim(`\n  Skills: All commands already migrated\n`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.dim(`  Could not read Claude Code commands: ${msg}\n`));
+    }
+  }
+
+  // ── Step 4: Save ──────────────────────────────────────────
+  if (changesMade) {
+    await saveSettings(acSettings);
+    console.log(chalk.green("  ✓ Settings saved to ~/.ashlrcode/settings.json"));
+    console.log(chalk.dim("  Restart AshlrCode for changes to take effect.\n"));
+  } else {
+    console.log(chalk.dim("  No changes needed — config is up to date.\n"));
+  }
+
+  // ── Summary ───────────────────────────────────────────────
+  console.log(chalk.white("  Next steps:"));
+  console.log(chalk.dim("  1. Set your API key: export XAI_API_KEY=your-key"));
+  console.log(chalk.dim("  2. Run: ac"));
+  console.log(chalk.dim("  3. Your MCP servers and skills will be available automatically\n"));
+}

package/src/persistence/session.ts

@@ -8,11 +8,12 @@
  */
 
 import { existsSync } from "fs";
-import { readFile, writeFile, appendFile, mkdir, readdir } from "fs/promises";
+import { readFile, appendFile, mkdir, readdir, unlink, stat } from "fs/promises";
 import { join } from "path";
 import { randomUUID } from "crypto";
 import { getConfigDir } from "../config/settings.ts";
 import type { Message } from "../providers/types.ts";
+import type { SessionId } from "../types/branded.ts";
 
 export interface SessionMetadata {
   id: string;
@@ -39,6 +40,12 @@ export class Session {
   readonly id: string;
   private filePath: string;
   private metadata: SessionMetadata;
+  /**
+   * Fire-and-forget write queue. Assistant messages are appended via this
+   * queue for low latency — writes are ordered but non-blocking. User messages
+   * bypass this queue and await directly (crash recovery requires durability).
+   */
+  private writeQueue: Promise<void> = Promise.resolve();
 
   constructor(id?: string) {
     this.id = id ?? randomUUID().slice(0, 8);
@@ -65,14 +72,32 @@ export class Session {
     });
   }
 
+  /**
+   * Append a message to the session log.
+   * User messages are written with blocking I/O (crash recovery).
+   * Assistant messages use fire-and-forget with ordering guarantees.
+   */
   async appendMessage(message: Message): Promise<void> {
     this.metadata.messageCount++;
     this.metadata.updatedAt = new Date().toISOString();
-    await this.appendEntry({
+    const entry: SessionEntry = {
       type: "message",
       timestamp: new Date().toISOString(),
       data: message,
-    });
+    };
+
+    if (message.role === "user") {
+      // Blocking write — if we crash, user input is preserved
+      await this.appendEntry(entry);
+    } else {
+      // Fire-and-forget with ordering — chain onto write queue
+      this.writeQueue = this.writeQueue.then(() =>
+        this.appendEntry(entry)
+      ).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error("[session] Fire-and-forget write failed:", msg);
+      });
+    }
   }
 
   async appendMessages(messages: Message[]): Promise<void> {
@@ -81,6 +106,11 @@ export class Session {
     }
   }
 
+  /** Wait for all queued writes to complete (call before exit). */
+  async flush(): Promise<void> {
+    await this.writeQueue;
+  }
+
   async insertCompactBoundary(summary: string, messageCountBefore: number): Promise<void> {
     await this.appendEntry({
       type: "compact",
@@ -178,8 +208,13 @@ export class Session {
   }
 
   private async appendEntry(entry: SessionEntry): Promise<void> {
-    await mkdir(getSessionsDir(), { recursive: true });
-    await appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf-8");
+    try {
+      await mkdir(getSessionsDir(), { recursive: true });
+      await appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf-8");
+    } catch (error: unknown) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error("[session] Failed to persist entry:", msg);
+    }
   }
 }
 
@@ -275,6 +310,9 @@ export async function forkSession(
 export async function compactSession(id: string): Promise<{ messagesBefore: number; summary: string }> {
   const session = new Session(id);
   const allMessages = await session.loadAllMessages();
+  if (allMessages.length === 0) {
+    throw new Error(`Session ${id} not found or empty`);
+  }
   const messagesBefore = allMessages.length;
 
   // Generate summary from recent messages
@@ -287,3 +325,169 @@ export async function compactSession(id: string): Promise<{ messagesBefore: numb
   await session.insertCompactBoundary(summary, messagesBefore);
   return { messagesBefore, summary };
 }
+
+/**
+ * Import a Claude Code JSONL session file into AshlrCode format.
+ *
+ * Claude Code sessions use JSONL with entries like:
+ *   {"type":"human","message":{"role":"user","content":"..."}}
+ *   {"type":"assistant","message":{"role":"assistant","content":[...]}}
+ *
+ * This is a best-effort parser — unparseable lines are skipped.
+ */
+export async function importClaudeCodeSession(
+  claudeSessionPath: string,
+  provider = "imported",
+  model = "claude-code"
+): Promise<Session> {
+  if (!existsSync(claudeSessionPath)) {
+    throw new Error(`Session file not found: ${claudeSessionPath}`);
+  }
+
+  const content = await readFile(claudeSessionPath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  const messages: Message[] = [];
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      // Claude Code format: {type: "human"|"assistant", message: {role, content}}
+      if (entry.message && entry.message.role && entry.message.content !== undefined) {
+        const role = entry.message.role;
+        if (role === "user" || role === "assistant") {
+          // Normalize content — Claude Code may use content blocks or strings
+          let normalizedContent: string;
+          if (typeof entry.message.content === "string") {
+            normalizedContent = entry.message.content;
+          } else if (Array.isArray(entry.message.content)) {
+            // Extract text from content blocks
+            const textParts: string[] = [];
+            for (const block of entry.message.content) {
+              if (block.type === "text" && block.text) {
+                textParts.push(block.text);
+              } else if (typeof block === "string") {
+                textParts.push(block);
+              }
+            }
+            normalizedContent = textParts.join("\n");
+          } else {
+            continue; // Skip entries with unrecognized content format
+          }
+
+          if (normalizedContent.trim()) {
+            messages.push({ role, content: normalizedContent });
+          }
+        }
+      }
+
+      // Alternative format: direct {role, content} entries (some Claude Code variants)
+      else if (entry.role && entry.content !== undefined && !entry.type) {
+        const role = entry.role;
+        if (role === "user" || role === "assistant") {
+          const normalizedContent = typeof entry.content === "string"
+            ? entry.content
+            : Array.isArray(entry.content)
+              ? entry.content
+                  .filter((b: Record<string, unknown>) => b.type === "text" && b.text)
+                  .map((b: Record<string, unknown>) => b.text as string)
+                  .join("\n")
+              : "";
+
+          if (normalizedContent.trim()) {
+            messages.push({ role, content: normalizedContent });
+          }
+        }
+      }
+
+      // AshlrCode's own format: {type: "message", data: {role, content}}
+      else if (entry.type === "message" && entry.data?.role) {
+        const role = entry.data.role;
+        if (role === "user" || role === "assistant") {
+          const normalizedContent = typeof entry.data.content === "string"
+            ? entry.data.content
+            : "";
+          if (normalizedContent.trim()) {
+            messages.push({ role, content: normalizedContent });
+          }
+        }
+      }
+    } catch {
+      // Skip unparseable lines
+    }
+  }
+
+  if (messages.length === 0) {
+    throw new Error("No parseable messages found in session file.");
+  }
+
+  const session = new Session();
+  await session.init(provider, model);
+  await session.appendMessages(messages);
+  await session.setTitle(`Imported from ${claudeSessionPath.split("/").pop() ?? "claude-code"}`);
+
+  return session;
+}
+
+/**
+ * Prune old session files. Keeps at most `maxCount` sessions,
+ * deleting the oldest by modification time. Optionally deletes
+ * sessions older than `maxAgeDays`.
+ *
+ * Returns the number of files deleted.
+ */
+export async function pruneOldSessions(
+  maxCount = 100,
+  maxAgeDays?: number
+): Promise<number> {
+  const sessionsDir = getSessionsDir();
+  if (!existsSync(sessionsDir)) return 0;
+
+  const files = await readdir(sessionsDir);
+  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+
+  if (jsonlFiles.length === 0) return 0;
+
+  // Get modification times for all session files
+  const fileStats = await Promise.all(
+    jsonlFiles.map(async (f) => {
+      const filePath = join(sessionsDir, f);
+      const s = await stat(filePath);
+      return { path: filePath, mtime: s.mtimeMs };
+    })
+  );
+
+  // Sort oldest first
+  fileStats.sort((a, b) => a.mtime - b.mtime);
+
+  const toDelete = new Set<string>();
+
+  // Mark files older than maxAgeDays
+  if (maxAgeDays !== undefined) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const f of fileStats) {
+      if (f.mtime < cutoff) {
+        toDelete.add(f.path);
+      }
+    }
+  }
+
+  // If still over maxCount after age pruning, trim oldest
+  const remaining = fileStats.filter((f) => !toDelete.has(f.path));
+  if (remaining.length > maxCount) {
+    const excess = remaining.length - maxCount;
+    for (let i = 0; i < excess; i++) {
+      toDelete.add(remaining[i]!.path);
+    }
+  }
+
+  for (const filePath of toDelete) {
+    try {
+      await unlink(filePath);
+    } catch {
+      // Ignore deletion errors (file may already be gone)
+    }
+  }
+
+  return toDelete.size;
+}