coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services/session-history-adapters/gemini.js → platforms/drivers/gemini/session-history-adapter.js}

@@ -4,10 +4,48 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { HOME_DIR } = require('../../../config/paths');
-const { getGeminiDir } = require('../gemini-config');
+const { getGeminiDir } = require('./config');
 
 const HASH_RE = /^[a-f0-9]{64}$/;
 const SESSION_FILE_RE = /^session-(.*)-([a-f0-9]+)\.(json|jsonl)$/;
+const DESCRIPTOR_HEADER_BYTES = 64 * 1024;
+
+function configure({ pathContext } = {}) {
+  require('./config').configure?.({ pathContext });
+}
+
+function readDescriptorMetadata(filePath, size) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(Math.min(Math.max(Number(size) || 0, 1), DESCRIPTOR_HEADER_BYTES));
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    const chunk = buffer.toString('utf8', 0, bytesRead);
+    let state = null;
+    try {
+      const parsed = JSON.parse(chunk);
+      state = parsed?.$set || parsed;
+    } catch (_) {
+      const firstLine = chunk.split(/\r?\n/, 1)[0];
+      try {
+        const parsed = JSON.parse(firstLine);
+        state = parsed?.$set || parsed;
+      } catch (_) {}
+    }
+    if (!state || typeof state !== 'object') return {};
+    return {
+      sessionId: state.sessionId || state.id || null,
+      projectHash: state.projectHash || state.project_hash || null,
+      projectPath: state.projectPath || state.project_path || state.cwd || null
+    };
+  } catch (_) {
+    return {};
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch (_) {}
+    }
+  }
+}
 
 /**
  * Extract text content from Gemini message parts.
@@ -30,10 +68,10 @@ function extractContentText(value) {
 /**
  * Load storage-name → project root mapping from projects.json.
  */
-function loadProjectRootsByStorageName() {
+async function loadProjectRootsByStorageName() {
   const projectsPath = path.join(getGeminiDir(), 'projects.json');
   try {
-    const content = fs.readFileSync(projectsPath, 'utf8');
+    const content = await fs.promises.readFile(projectsPath, 'utf8');
     const parsed = JSON.parse(content);
     const projects = parsed && typeof parsed.projects === 'object' ? parsed.projects : {};
     return new Map(
@@ -122,7 +160,7 @@ function parseSessionContentFromState(state, sessionId) {
   const meta = {
     sessionId: state.sessionId || state.id || sessionId,
     projectHash: state.projectHash || state.project_hash || null,
-    projectPath: state.projectPath || state.project_path || null,
+    projectPath: state.projectPath || state.project_path || state.cwd || null,
     lastUpdated: state.lastUpdated || state.last_updated || null,
     messages: state.messages || []
   };
@@ -194,12 +232,16 @@ async function inventory() {
   const descriptors = [];
   const tmpDir = path.join(getGeminiDir(), 'tmp');
 
-  if (!fs.existsSync(tmpDir)) return descriptors;
+  try {
+    await fs.promises.stat(tmpDir);
+  } catch (_) {
+    return descriptors;
+  }
 
-  const projectRoots = loadProjectRootsByStorageName();
+  const projectRoots = await loadProjectRootsByStorageName();
   let entries;
   try {
-    entries = fs.readdirSync(tmpDir, { withFileTypes: true });
+    entries = await fs.promises.readdir(tmpDir, { withFileTypes: true });
   } catch (_) {
     return descriptors;
   }
@@ -208,11 +250,15 @@ async function inventory() {
     if (!entry.isDirectory()) continue;
     const hashDir = path.join(tmpDir, entry.name);
     const chatsDir = path.join(hashDir, 'chats');
-    if (!fs.existsSync(chatsDir)) continue;
+    try {
+      await fs.promises.stat(chatsDir);
+    } catch (_) {
+      continue;
+    }
 
     let chatFiles;
     try {
-      chatFiles = fs.readdirSync(chatsDir);
+      chatFiles = await fs.promises.readdir(chatsDir);
     } catch (_) {
       continue;
     }
@@ -223,24 +269,27 @@ async function inventory() {
       const filePath = path.join(chatsDir, f);
       let stat;
       try {
-        stat = fs.statSync(filePath);
+        stat = await fs.promises.stat(filePath);
       } catch (_) {
         continue;
       }
-      const projectRoot = projectRoots.get(entry.name) || (() => {
+      const header = readDescriptorMetadata(filePath, stat.size);
+      let projectRoot = projectRoots.get(entry.name) || null;
+      if (!projectRoot) {
         try {
-          return fs.readFileSync(path.join(hashDir, '.project_root'), 'utf8').trim() || null;
+          projectRoot = (await fs.promises.readFile(path.join(hashDir, '.project_root'), 'utf8')).trim() || null;
         } catch (_) {
-          return null;
+          projectRoot = null;
         }
-      })();
+      }
+      projectRoot = header.projectPath || projectRoot;
 
       descriptors.push({
         filePath,
         size: stat.size,
         mtimeMs: stat.mtimeMs,
-        sessionId: match[1],
-        projectName: projectRoot ? getFilePathHash(projectRoot) : entry.name,
+        sessionId: header.sessionId || match[2] || match[1],
+        projectName: header.projectHash || (projectRoot ? getFilePathHash(projectRoot) : entry.name),
         projectRoot
       });
     }
@@ -257,8 +306,11 @@ async function parse(descriptor) {
 
   const { messages, meta } = parseSessionContent(filePath, sessionId);
   const resolvedSessionId = meta.sessionId || sessionId;
-  const resolvedProjectName = meta.projectHash || projectName || 'unknown';
   const resolvedProjectPath = meta.projectPath || projectRoot || null;
+  const resolvedProjectName = meta.projectHash
+    || (resolvedProjectPath ? getFilePathHash(resolvedProjectPath) : null)
+    || projectName
+    || 'unknown';
   const firstUserMsg = messages.find(m => m.role === 'user' && m.content);
   const usage = messages.reduce((total, message) => {
     const value = message.usage || {};
@@ -289,4 +341,4 @@ async function parse(descriptor) {
   return { session, messages };
 }
 
-module.exports = { inventory, parse, extractContentText, normalizeMessageRecord, parseSessionContent };
+module.exports = { configure, inventory, parse, extractContentText, normalizeMessageRecord, parseSessionContent };

package/src/{server/services/gemini-sessions.js → platforms/drivers/gemini/sessions-implementation.js}

@@ -1,10 +1,31 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { HOME_DIR } = require('../../config/paths');
-const { getGeminiDir } = require('./gemini-config');
-const { resolveModelPricing } = require('../utils/pricing');
-const { listProjects: idxListProjects, listSessions: idxListSessions, getSessionStatus: idxGetSessionStatus, getRecentSessions: idxGetRecent, searchSessions: idxSearch } = require('./session-history-index');
+const { HOME_DIR } = require('../../../config/paths');
+const { getGeminiDir } = require('./config');
+const { normalizeUsageTokens } = require('../../../server/services/usage-log-utils');
+const { resolveModelPricing, calculateTokenCost } = require('../../../server/utils/pricing');
+let sessionHistoryIndex = null;
+let geminiDirOverride = null;
+
+function configure({ sessionHistoryIndex: index, pathContext } = {}) {
+  sessionHistoryIndex = index || null;
+  geminiDirOverride = pathContext?.customized ? (pathContext.native?.dir || null) : null;
+}
+
+function getSessionHistoryIndex(options = {}) {
+  if (!sessionHistoryIndex) {
+    const { getDefaultDependencies } = require('../../../platforms/runtime');
+    sessionHistoryIndex = getDefaultDependencies().sessionHistoryIndex;
+    if (!sessionHistoryIndex) {
+      const indexModule = require('../../../server/services/session-history-index');
+      sessionHistoryIndex = Object.keys(options).length > 0
+        ? indexModule.createSessionHistoryIndex({ config: options })
+        : indexModule;
+    }
+  }
+  return sessionHistoryIndex;
+}
 
 const HASH_RE = /^[a-f0-9]{64}$/;
 const SESSION_FILE_RE = /^session-(.*)-([a-f0-9]+)\.(json|jsonl)$/;
@@ -18,7 +39,7 @@ const PATH_MAPPING_CACHE_TTL = 60000; // 1分钟缓存
  * 获取 Gemini tmp 目录（包含所有项目）
  */
 function getTmpDir() {
-  return path.join(getGeminiDir(), 'tmp');
+  return path.join(geminiDirOverride || getGeminiDir(), 'tmp');
 }
 
 /**
@@ -52,7 +73,7 @@ function readProjectRootFile(projectDir) {
 }
 
 function loadProjectRootsByStorageName() {
-  const projectsPath = path.join(getGeminiDir(), 'projects.json');
+  const projectsPath = path.join(geminiDirOverride || getGeminiDir(), 'projects.json');
   const content = readTextFile(projectsPath);
   if (!content) {
     return new Map();
@@ -487,17 +508,15 @@ function readSessionMeta(filePath) {
 
     messages.forEach(msg => {
       if (msg.tokens) {
-        totalTokens += msg.tokens.total || 0;
+        const tokens = normalizeUsageTokens('gemini', msg.tokens);
+        totalTokens += tokens.total || 0;
 
-        // 计算成本（简化版本，使用 gemini-2.5-pro 的定价）
         if (msg.model) {
           model = msg.model;
-          const inputTokens = msg.tokens.input || 0;
-          const outputTokens = msg.tokens.output || 0;
           const pricing = resolveModelPricing('gemini', msg.model);
-          const inputRate = typeof pricing.input === 'number' ? pricing.input : 1.25;
-          const outputRate = typeof pricing.output === 'number' ? pricing.output : 10;
-          totalCost += (inputTokens * inputRate / 1000000) + (outputTokens * outputRate / 1000000);
+          totalCost += calculateTokenCost(pricing, tokens, {
+            reasoningBilledAsOutput: true
+          });
         }
       }
     });
@@ -630,7 +649,7 @@ function getProjectPath(projectHash, options = {}) {
  * @returns {Array} 项目对象数组
  */
 async function getProjects(options = {}) {
-  const projects = await idxListProjects('gemini', options);
+  const projects = await getSessionHistoryIndex().listProjects('gemini', options);
   const paths = buildPathMapping();
   return projects.map(project => {
     const fullPath = project.fullPath || paths.get(project.name) || null;
@@ -651,7 +670,7 @@ async function getProjects(options = {}) {
  * @returns {Array} 会话对象数组
  */
 async function getProjectSessions(projectHash, options = {}) {
-  const indexed = await idxListSessions('gemini', projectHash, options);
+  const indexed = await getSessionHistoryIndex().listSessions('gemini', projectHash, options);
   return indexed.map(session => ({
     sessionId: session.sessionId,
     mtime: new Date(session.mtime).toISOString(),
@@ -677,7 +696,7 @@ async function getProjectSessions(projectHash, options = {}) {
  * @returns {Object|null} 完整会话数据
  */
 async function getSession(sessionId) {
-  const status = await idxGetSessionStatus('gemini', sessionId);
+  const status = await getSessionHistoryIndex().getSessionStatus('gemini', sessionId);
   return status ? readSessionFull(status.filePath) : null;
 }
 
@@ -696,6 +715,7 @@ function deleteSession(sessionId) {
 
   try {
     fs.unlinkSync(session.filePath);
+    getSessionHistoryIndex().invalidateSource('gemini');
     return { success: true, sessionId };
   } catch (err) {
     throw new Error('Failed to delete session: ' + err.message);
@@ -718,6 +738,7 @@ function deleteProject(projectHash) {
 
   try {
     fs.rmSync(projectDir, { recursive: true, force: true });
+    getSessionHistoryIndex().invalidateSource('gemini', { projectName: projectHash });
     return { success: true, projectHash };
   } catch (err) {
     throw new Error('Failed to delete project: ' + err.message);
@@ -740,7 +761,7 @@ function saveProjectOrder(order) {
  * @returns {Array} 会话对象数组
  */
 async function getRecentSessions(limit = 5) {
-  const sessions = await idxGetRecent('gemini', limit);
+  const sessions = await getSessionHistoryIndex().getRecentSessions('gemini', limit);
   return sessions.map(session => ({
     ...session,
     mtime: new Date(session.mtime).toISOString(),
@@ -754,7 +775,7 @@ async function getRecentSessions(limit = 5) {
  * @returns {Object|null} 完整会话数据
  */
 async function getSessionById(sessionId) {
-  const status = await idxGetSessionStatus('gemini', sessionId);
+  const status = await getSessionHistoryIndex().getSessionStatus('gemini', sessionId);
   if (!status) return null;
   const fullSession = readSessionFull(status.filePath);
   if (!fullSession) return null;
@@ -773,8 +794,11 @@ async function getSessionById(sessionId) {
  * @param {number} contextLength - 上下文长度（可选）
  * @returns {Array} 搜索结果数组
  */
-async function searchSessions(keyword, contextLength = 35) {
-  const results = await idxSearch('gemini', keyword, { contextLength });
+async function searchSessions(keyword, contextLength = 35, options = {}) {
+  const results = await getSessionHistoryIndex().searchSessions('gemini', keyword, {
+    ...options,
+    contextLength
+  });
   return results.map(result => ({
     sessionId: result.sessionId,
     projectHash: result.projectName,
@@ -879,10 +903,11 @@ function forkSession(sessionId, options = {}) {
       fs.writeFileSync(newFilePath, JSON.stringify(newSession, null, 2), 'utf8');
     }
     if (options.alias) {
-      const { setAlias } = require('./alias');
+      const { setAlias } = require('../../../server/services/alias');
       setAlias(newSessionId, options.alias);
     }
 
+    getSessionHistoryIndex(options).invalidateSource('gemini');
     return {
       success: true,
       sessionId: newSessionId,
@@ -899,25 +924,16 @@ function forkSession(sessionId, options = {}) {
 /**
  * 获取 Gemini 项目与会话数量（仪表盘轻量统计）
  */
-function getProjectAndSessionCounts() {
-  try {
-    const projectEntries = scanProjectEntries();
-    let sessionCount = 0;
-    const projectHashes = new Set();
-    projectEntries.forEach((entry) => {
-      projectHashes.add(resolveProjectHashForEntry(entry));
-      sessionCount += scanEntrySessionFiles(entry).length;
-    });
-    return {
-      projectCount: Array.from(projectHashes).filter(Boolean).length,
-      sessionCount
-    };
-  } catch (err) {
-    return { projectCount: 0, sessionCount: 0 };
-  }
+async function getProjectAndSessionCounts(options = {}) {
+  const projects = await getSessionHistoryIndex().listProjects('gemini', options);
+  return {
+    projectCount: projects.length,
+    sessionCount: projects.reduce((sum, project) => sum + (project.sessionCount || 0), 0)
+  };
 }
 
 module.exports = {
+  configure,
   getAllSessions,
   getProjects,
   getProjectSessions,

package/src/platforms/drivers/gemini/sessions.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'gemini',
+    capability: 'sessions',
+    parserVersion: 2,
+    servicePath: './gemini/sessions-implementation',
+    localServicePath: '../platforms/drivers/gemini/sessions-implementation',
+    adapterLocalPath: '../platforms/drivers/gemini/session-history-adapter',
+    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    methods: {
+      listSessions: 'getProjectSessions',
+      recent: 'getRecentSessions',
+      getSessionById: 'getSessionById',
+      getAllSessions: 'getAllSessions',
+      delete: 'deleteSession',
+      fork: 'forkSession',
+      saveSessionOrder: 'saveSessionOrder',
+      getProjectPath: 'getProjectPath',
+      status: 'getSessionStatus',
+      messages: 'getSessionMessages'
+    },
+    customMethods: {
+      search: (service, projectName, keyword, contextLength, options = {}) => service.searchSessions(
+        keyword,
+        contextLength,
+        { ...options, projectName }
+      ),
+      searchAcrossProjects: (service, keyword, contextLength, options = {}) => service.searchSessions(
+        keyword,
+        contextLength,
+        options
+      )
+    },
+    onSuccess: operation => {
+      if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('gemini');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/{server/services/gemini-statistics-service.js → platforms/drivers/gemini/statistics-implementation.js}

@@ -3,8 +3,8 @@ const {
   getStatistics: getSharedStatistics,
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
-} = require('./statistics-service');
-const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
+} = require('../../../server/services/statistics-service');
+const { normalizeUsageTokens, toNumber } = require('../../../server/services/usage-log-utils');
 
 const TOOL_TYPE = 'gemini';
 

package/src/platforms/drivers/gemini/statistics.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'gemini',
+    capability: 'statistics',
+    servicePath: './gemini/statistics-implementation',
+    localServicePath: '../platforms/drivers/gemini/statistics-implementation',
+    methods: {"getStatistics":"getStatistics","getDailyStatistics":"getDailyStatistics","getTodayStatistics":"getTodayStatistics","recordRequest":"recordRequest","resetStatistics":"resetStatistics"}
+  });
+}
+
+module.exports = { createDriver };

package/src/{server/services/gemini-wire.js → platforms/drivers/gemini/wire.js}

@@ -6,7 +6,7 @@ const {
   normalizeToolResultContent,
   extractText,
   normalizeStopSequences
-} = require('./opencode-normalization');
+} = require('../opencode/normalization');
 
 // ---------------------------------------------------------------------------
 // Gemini CLI constants

package/src/platforms/drivers/generic-filesystem.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+
+function failure({ platform, operation, type, name, error }) {
+  const result = {
+    status: 'failed',
+    platform,
+    capability: 'resourceSync',
+    operation,
+    error: error && error.message ? error.message : String(error)
+  };
+  if (type !== undefined) result.type = type;
+  if (name !== undefined) result.name = name;
+  if (error) Object.defineProperty(result, 'cause', { value: error, enumerable: false });
+  return result;
+}
+
+function mappedRoot(manifest, type) {
+  const mapping = manifest.resourceMappings || {};
+  return mapping[type] || (manifest.paths && manifest.paths[type]);
+}
+
+function normalizeName(name) {
+  const rawName = String(name || '');
+  if (path.isAbsolute(rawName)) throw new Error(`Resource path must be relative: ${name}`);
+  const normalizedName = path.normalize(rawName);
+  if (!normalizedName || normalizedName === '.' || normalizedName === '..' || normalizedName.startsWith(`..${path.sep}`)) {
+    throw new Error(`Resource path escapes target root: ${name}`);
+  }
+  return normalizedName;
+}
+
+function resolveTarget(root, name) {
+  const normalizedName = normalizeName(name);
+  const resolvedRoot = path.resolve(root);
+  const target = path.resolve(resolvedRoot, normalizedName);
+  const relative = path.relative(resolvedRoot, target);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`Resource path escapes target root: ${name}`);
+  }
+  return target;
+}
+async function assertNoSymlinkComponents(fsImpl, target) {
+  if (typeof fsImpl.lstat !== 'function') return;
+  const resolved = path.resolve(target);
+  const root = path.parse(resolved).root;
+  const parts = path.relative(root, resolved).split(path.sep).filter(Boolean);
+  let current = root;
+  for (let index = 0; index < parts.length; index += 1) {
+    current = path.join(current, parts[index]);
+    try {
+      const stat = await fsImpl.lstat(current);
+      if (index > 0 && stat.isSymbolicLink()) throw new Error(`Resource path contains symlink: ${target}`);
+    } catch (error) {
+      if (error.code === 'ENOENT') break;
+      throw error;
+    }
+  }
+  const finalStat = await fsImpl.lstat(resolved).catch(error => {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  });
+  if (finalStat && finalStat.isSymbolicLink()) throw new Error(`Resource path contains symlink: ${target}`);
+}
+
+async function assertSafeRoot(fsImpl, root, { allowMissingRoot = false } = {}) {
+  if (typeof fsImpl.realpath !== 'function' || typeof fsImpl.lstat !== 'function') return path.resolve(root);
+  const resolvedRoot = path.resolve(root);
+  await assertNoSymlinkComponents(fsImpl, resolvedRoot);
+  try {
+    return await fsImpl.realpath(resolvedRoot);
+  } catch (error) {
+    if (error.code !== 'ENOENT' || !allowMissingRoot) throw error;
+    let current = path.dirname(resolvedRoot);
+    while (true) {
+      try {
+        await assertNoSymlinkComponents(fsImpl, current);
+        return await fsImpl.realpath(current);
+      } catch (parentError) {
+        if (parentError.code !== 'ENOENT') throw parentError;
+        const next = path.dirname(current);
+        if (next === current) return resolvedRoot;
+        current = next;
+      }
+    }
+  }
+}
+
+async function assertContainedTarget(fsImpl, root, target, { allowMissingTarget = false, allowMissingRoot = false } = {}) {
+  if (typeof fsImpl.realpath !== 'function' || typeof fsImpl.lstat !== 'function') return;
+  const rootReal = await assertSafeRoot(fsImpl, root, { allowMissingRoot });
+  await assertNoSymlinkComponents(fsImpl, target);
+  const targetReal = await fsImpl.realpath(target).catch(error => {
+    if (allowMissingTarget && error.code === 'ENOENT') return null;
+    throw error;
+  });
+  if (!targetReal) return;
+  const relative = path.relative(rootReal, targetReal);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`Resource path escapes target root: ${target}`);
+  }
+}
+function createGenericFilesystemDriver({ platform, manifest = {}, fsImpl = fs } = {}) {
+  function getRoot(type) {
+    const root = mappedRoot(manifest, type);
+    if (!root) throw new Error(`Unknown resource mapping: ${type}`);
+    return root;
+  }
+
+  return {
+    async list(type) {
+      try {
+        const root = getRoot(type);
+        await assertSafeRoot(fsImpl, root);
+        const names = await fsImpl.readdir(root);
+        const resources = [];
+        for (const name of names) {
+          const target = resolveTarget(root, name);
+          await assertContainedTarget(fsImpl, root, target);
+          const stat = await fsImpl.stat(target);
+          resources.push({ name, target, type: stat.isDirectory() ? 'directory' : 'file', size: stat.size, mtimeMs: stat.mtimeMs });
+        }
+        return resources;
+      } catch (error) {
+        return failure({ platform, operation: 'list', type, error });
+      }
+    },
+    async sync(type, name, sourceRoot) {
+      try {
+        const root = getRoot(type);
+        const target = resolveTarget(root, name);
+        await assertSafeRoot(fsImpl, root, { allowMissingRoot: true });
+        await assertContainedTarget(fsImpl, root, path.dirname(target), { allowMissingTarget: true, allowMissingRoot: true });
+        const sourceStat = await fsImpl.stat(sourceRoot);
+        await fsImpl.mkdir(path.dirname(target), { recursive: true });
+        await assertSafeRoot(fsImpl, root);
+        await assertContainedTarget(fsImpl, root, path.dirname(target));
+        await assertContainedTarget(fsImpl, root, target, { allowMissingTarget: true });
+        if (sourceStat.isDirectory()) {
+          await fsImpl.cp(sourceRoot, target, { recursive: true });
+        } else {
+          await fsImpl.copyFile(sourceRoot, target);
+        }
+        return { status: 'ok', target };
+      } catch (error) {
+        return failure({ platform, operation: 'sync', type, name, error });
+      }
+    },
+    async remove(type, name) {
+      try {
+        const root = getRoot(type);
+        const target = resolveTarget(root, name);
+        await assertSafeRoot(fsImpl, root);
+        await assertContainedTarget(fsImpl, root, target, { allowMissingTarget: true });
+        await fsImpl.rm(target, { recursive: true, force: true });
+        return { status: 'ok', target };
+      } catch (error) {
+        return failure({ platform, operation: 'remove', type, name, error });
+      }
+    }
+  };
+}
+
+module.exports = { createGenericFilesystemDriver };