wehub-resource-sync
1318 lines
38 KiB
TypeScript
1318 lines
38 KiB
TypeScript
/**
|
|
* File System Service
|
|
*
|
|
* Provides a virtual file system for the simulated Android environment.
|
|
* Uses IndexedDB for persistent storage.
|
|
*
|
|
* 设计目标（V2）：
|
|
* - 仅在「首次初始化」或「手动 reset」时，从 public/sdcard 扫描并全量导入（meta + content）到 IndexedDB
|
|
* - 常规启动只从 IndexedDB 读取，不再运行时扫描/合并 public/sdcard
|
|
* - 这样预置文件与运行中写入文件拥有一致语义（可重命名/移动/删除且跨重启保持）
|
|
*/
|
|
import { FSNode, PresetFile } from './types';
|
|
import { FILE_SYSTEM_CONFIG } from './data/fileSystemConfig';
|
|
import { getNamespacedIndexedDbName } from './storageIsolation';
|
|
import * as TimeService from './TimeService';
|
|
|
|
// API 响应结构
|
|
interface ScanResult {
|
|
totalFiles: number;
|
|
totalDirectories: number;
|
|
files: {
|
|
path: string;
|
|
uri: string;
|
|
name: string;
|
|
mimeType: string;
|
|
size: number;
|
|
modifiedAt?: number;
|
|
}[];
|
|
directories: {
|
|
path: string;
|
|
name: string;
|
|
modifiedAt?: number;
|
|
}[];
|
|
}
|
|
|
|
// ============================================================================
|
|
// Internal State
|
|
// ============================================================================
|
|
interface FileSystemState {
|
|
nodes: Map<string, FSNode>;
|
|
pathIndex: Map<string, string>; // path -> id
|
|
initialized: boolean;
|
|
}
|
|
|
|
let state: FileSystemState = {
|
|
nodes: new Map(),
|
|
pathIndex: new Map(),
|
|
initialized: false,
|
|
};
|
|
|
|
// IndexedDB configuration
|
|
const DB_NAME = getNamespacedIndexedDbName('SimFileSystem');
|
|
const DB_VERSION = 2;
|
|
const STORE_FILES = 'files';
|
|
const STORE_METADATA = 'metadata';
|
|
const STORE_SYSTEM = 'system';
|
|
|
|
const SEED_MARKER_ID = '__fs_seed__';
|
|
// Bump this when the preset sdcard seed structure changes.
|
|
// This will trigger a one-time re-import from public/sdcard on next startup.
|
|
const SEED_SCHEMA_VERSION = 2 as const;
|
|
|
|
|
|
type SeedMarker = {
|
|
id: typeof SEED_MARKER_ID;
|
|
version: typeof SEED_SCHEMA_VERSION;
|
|
status: 'in_progress' | 'complete';
|
|
importedAt?: number;
|
|
source?: 'public/sdcard' | 'config' | 'none' | 'legacy_migration';
|
|
note?: string;
|
|
};
|
|
|
|
|
|
let db: IDBDatabase | null = null;
|
|
let dbClosed = false;
|
|
|
|
/**
|
|
* Get a valid IDBDatabase handle, reopening the connection if needed.
|
|
* Returns null only when IndexedDB is fundamentally unavailable.
|
|
*/
|
|
async function ensureDb(): Promise<IDBDatabase | null> {
|
|
if (db && !dbClosed) return db;
|
|
try {
|
|
db = await openDatabase();
|
|
dbClosed = false;
|
|
return db;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// Initialization
|
|
// ============================================================================
|
|
|
|
/**
|
|
* 实时扫描 public/sdcard 目录
|
|
* 通过 Vite 服务器的 /api/sdcard 端点获取
|
|
*/
|
|
async function scanSdcard(): Promise<ScanResult | null> {
|
|
// 1. Try dev-server API (only available in `npm run dev`)
|
|
try {
|
|
const response = await fetch('/api/sdcard');
|
|
if (response.ok) {
|
|
const result = await response.json();
|
|
console.log(`[FileSystem] Scanned ${result.totalFiles} files from /api/sdcard`);
|
|
return result;
|
|
}
|
|
} catch {
|
|
// API not available — likely production build
|
|
}
|
|
|
|
// 2. Fallback: static manifest emitted during `npm run build`
|
|
try {
|
|
const response = await fetch(`${import.meta.env.BASE_URL}sdcard/manifest.json`);
|
|
if (response.ok) {
|
|
const result = await response.json();
|
|
console.log(`[FileSystem] Loaded ${result.totalFiles} files from static .manifest.json`);
|
|
return result;
|
|
}
|
|
} catch {
|
|
// Manifest not available either
|
|
}
|
|
|
|
console.log('[FileSystem] No scan API or manifest available');
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Shared initialization promise to prevent race conditions.
|
|
* Multiple callers (e.g. OSProvider, ThemeProvider) may call initFileSystem()
|
|
* concurrently; we must ensure only one initialization runs.
|
|
*/
|
|
let initPromise: Promise<void> | null = null;
|
|
|
|
/**
|
|
* Initialize the file system
|
|
* Call this on app startup
|
|
*/
|
|
export async function initFileSystem(): Promise<void> {
|
|
if (state.initialized) return;
|
|
if (initPromise) return initPromise;
|
|
initPromise = initFileSystemInternal();
|
|
return initPromise;
|
|
}
|
|
|
|
async function initFileSystemInternal(): Promise<void> {
|
|
try {
|
|
db = await openDatabase();
|
|
dbClosed = false;
|
|
await loadOrCreateState();
|
|
state.initialized = true;
|
|
exposeAgentAPI();
|
|
console.log('[FileSystem] Initialized with', state.nodes.size, 'nodes');
|
|
} catch (error) {
|
|
console.error('[FileSystem] Initialization failed:', error);
|
|
await createBaseStateInMemory();
|
|
state.initialized = true;
|
|
exposeAgentAPI();
|
|
}
|
|
}
|
|
|
|
async function openDatabase(): Promise<IDBDatabase> {
|
|
return new Promise((resolve, reject) => {
|
|
const request = indexedDB.open(DB_NAME, DB_VERSION);
|
|
|
|
request.onerror = () => reject(request.error);
|
|
request.onsuccess = () => {
|
|
const database = request.result;
|
|
|
|
database.onversionchange = () => {
|
|
database.close();
|
|
dbClosed = true;
|
|
db = null;
|
|
console.warn('[FileSystem] DB connection closed due to versionchange');
|
|
};
|
|
|
|
database.onclose = () => {
|
|
dbClosed = true;
|
|
db = null;
|
|
console.warn('[FileSystem] DB connection closed unexpectedly');
|
|
};
|
|
|
|
resolve(database);
|
|
};
|
|
|
|
request.onupgradeneeded = (event) => {
|
|
const database = (event.target as IDBOpenDBRequest).result;
|
|
|
|
if (!database.objectStoreNames.contains(STORE_FILES)) {
|
|
database.createObjectStore(STORE_FILES, { keyPath: 'id' });
|
|
}
|
|
|
|
if (!database.objectStoreNames.contains(STORE_METADATA)) {
|
|
const metaStore = database.createObjectStore(STORE_METADATA, { keyPath: 'id' });
|
|
metaStore.createIndex('path', 'path', { unique: true });
|
|
metaStore.createIndex('parentId', 'parentId');
|
|
}
|
|
|
|
if (!database.objectStoreNames.contains(STORE_SYSTEM)) {
|
|
database.createObjectStore(STORE_SYSTEM, { keyPath: 'id' });
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
async function loadOrCreateState(): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) {
|
|
await createBaseStateInMemory();
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await ensureSeedImportedIfNeeded();
|
|
|
|
const savedNodes = await loadMetadataFromDB();
|
|
if (savedNodes.length === 0) {
|
|
await createBaseStateInMemory();
|
|
await persistAllMetadata();
|
|
} else {
|
|
state.nodes = new Map(savedNodes.map(n => [n.id, n]));
|
|
state.pathIndex = new Map(savedNodes.map(n => [n.path, n.id]));
|
|
}
|
|
|
|
} catch (error) {
|
|
console.error('[FileSystem] Failed to load state:', error);
|
|
await createBaseStateInMemory();
|
|
}
|
|
}
|
|
|
|
|
|
async function createBaseStateInMemory(): Promise<void> {
|
|
state.nodes = new Map();
|
|
state.pathIndex = new Map();
|
|
|
|
const now = TimeService.now();
|
|
|
|
// Create root directory
|
|
const root: FSNode = {
|
|
id: 'root',
|
|
name: '/',
|
|
type: 'directory',
|
|
parentId: null,
|
|
path: '/',
|
|
size: 0,
|
|
createdAt: now,
|
|
modifiedAt: now,
|
|
storage: 'memory',
|
|
};
|
|
state.nodes.set(root.id, root);
|
|
state.pathIndex.set(root.path, root.id);
|
|
|
|
// Create preset directories
|
|
for (const dir of FILE_SYSTEM_CONFIG.presetStructure) {
|
|
ensureDirectorySync(dir.path);
|
|
}
|
|
}
|
|
|
|
function ensureDirectorySync(path: string): FSNode | null {
|
|
const normalPath = normalizePath(path);
|
|
|
|
// Check if already exists
|
|
const existingId = state.pathIndex.get(normalPath);
|
|
if (existingId) {
|
|
const existing = state.nodes.get(existingId) || null;
|
|
return existing?.type === 'directory' ? existing : null;
|
|
}
|
|
|
|
// Recursively create parent first
|
|
const parentPath = getParentPath(normalPath);
|
|
if (parentPath !== normalPath && parentPath !== '') {
|
|
ensureDirectorySync(parentPath);
|
|
}
|
|
|
|
// Create this directory
|
|
const name = getFileName(normalPath);
|
|
const parentId = state.pathIndex.get(parentPath) || 'root';
|
|
const now = TimeService.now();
|
|
|
|
const node: FSNode = {
|
|
id: `dir_${TimeService.now()}_${Math.random().toString(36).slice(2, 8)}`,
|
|
name,
|
|
type: 'directory',
|
|
parentId,
|
|
path: normalPath,
|
|
size: 0,
|
|
createdAt: now,
|
|
modifiedAt: now,
|
|
storage: 'memory',
|
|
};
|
|
|
|
state.nodes.set(node.id, node);
|
|
state.pathIndex.set(normalPath, node.id);
|
|
|
|
return node;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Public API - Read Operations
|
|
// ============================================================================
|
|
|
|
/**
|
|
* List contents of a directory
|
|
*/
|
|
export function listDirectory(path: string): FSNode[] {
|
|
const normalPath = normalizePath(path);
|
|
const dirId = state.pathIndex.get(normalPath);
|
|
|
|
if (!dirId) return [];
|
|
|
|
return Array.from(state.nodes.values())
|
|
.filter(node => node.parentId === dirId)
|
|
.sort((a, b) => {
|
|
// Directories first, then by name
|
|
if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
|
|
return a.name.localeCompare(b.name);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get a node by path
|
|
*/
|
|
export function getNode(path: string): FSNode | null {
|
|
const id = state.pathIndex.get(normalizePath(path));
|
|
return id ? state.nodes.get(id) || null : null;
|
|
}
|
|
|
|
/**
|
|
* Check if a path exists
|
|
*/
|
|
export function exists(path: string): boolean {
|
|
return state.pathIndex.has(normalizePath(path));
|
|
}
|
|
|
|
// Blob URL 缓存 - 用于 IndexedDB 文件
|
|
const blobUrlCache = new Map<string, string>();
|
|
|
|
/**
|
|
* 把存储的根绝对路径（如 /sdcard/DCIM/...）转成可 fetch 的 URL，带上部署 base。
|
|
* public/sdcard/* 在 build 时被发布到 <BASE_URL>sdcard/*；根部署 base='/' 时原样返回，
|
|
* demo 分支 /sim/ 子路径部署时变成 /sim/sdcard/...。非根绝对路径（http/blob/相对）原样放过。
|
|
*/
|
|
function presetAssetUrl(p: string): string {
|
|
if (!p.startsWith('/')) return p;
|
|
return import.meta.env.BASE_URL + p.slice(1);
|
|
}
|
|
|
|
/**
|
|
* Get the URI for displaying a file (sync version)
|
|
* For preset files, returns the public path
|
|
* For IndexedDB files, returns cached blob URL or null
|
|
*/
|
|
export function getFileUri(path: string): string | null {
|
|
const node = getNode(path);
|
|
if (!node || node.type !== 'file') return null;
|
|
|
|
// Legacy compatibility: old DB may still contain preset nodes.
|
|
// In Vite dev/build, public/sdcard/* is served at /sdcard/* so node.path is fetchable.
|
|
if (node.storage === 'preset') return presetAssetUrl(node.path);
|
|
|
|
// For IndexedDB files, check cache
|
|
if (blobUrlCache.has(node.id)) {
|
|
return blobUrlCache.get(node.id)!;
|
|
}
|
|
|
|
// 返回 null，调用者应该使用 getFileUriAsync
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Get the URI for displaying a file (async version)
|
|
* Creates Blob URLs for IndexedDB files and caches them
|
|
*/
|
|
export async function getFileUriAsync(path: string): Promise<string | null> {
|
|
const node = getNode(path);
|
|
if (!node || node.type !== 'file') return null;
|
|
|
|
if (node.storage === 'preset') return getFileUri(path);
|
|
|
|
// For IndexedDB files
|
|
if (blobUrlCache.has(node.id)) {
|
|
return blobUrlCache.get(node.id)!;
|
|
}
|
|
|
|
// Load from IndexedDB and create Blob URL
|
|
const blob = await loadFileFromDB(node.id);
|
|
if (!blob) return null;
|
|
|
|
const blobUrl = URL.createObjectURL(blob);
|
|
blobUrlCache.set(node.id, blobUrl);
|
|
|
|
return blobUrl;
|
|
}
|
|
|
|
/**
|
|
* Clear a blob URL from cache (call when file is deleted)
|
|
*/
|
|
function clearBlobUrlCache(nodeId: string): void {
|
|
const url = blobUrlCache.get(nodeId);
|
|
if (url) {
|
|
URL.revokeObjectURL(url);
|
|
blobUrlCache.delete(nodeId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read file content as Blob
|
|
*/
|
|
export async function readFile(path: string): Promise<Blob | null> {
|
|
const node = getNode(path);
|
|
if (!node || node.type !== 'file') return null;
|
|
|
|
if (node.storage === 'preset') {
|
|
try {
|
|
const response = await fetch(presetAssetUrl(node.path));
|
|
return await response.blob();
|
|
} catch (error) {
|
|
console.error('[FileSystem] Failed to fetch preset file:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (node.storage === 'indexeddb') {
|
|
return loadFileFromDB(node.id);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Get all media files (images and videos)
|
|
*/
|
|
export function getMediaFiles(type?: 'image' | 'video' | 'audio'): FSNode[] {
|
|
const mimePrefix = type === 'image' ? 'image/'
|
|
: type === 'video' ? 'video/'
|
|
: type === 'audio' ? 'audio/'
|
|
: null;
|
|
|
|
return Array.from(state.nodes.values())
|
|
.filter(node => {
|
|
if (node.type !== 'file') return false;
|
|
if (!node.mimeType) return false;
|
|
|
|
if (mimePrefix) {
|
|
return node.mimeType.startsWith(mimePrefix);
|
|
}
|
|
|
|
// Return all media types
|
|
return node.mimeType.startsWith('image/') ||
|
|
node.mimeType.startsWith('video/') ||
|
|
node.mimeType.startsWith('audio/');
|
|
})
|
|
.sort((a, b) => b.modifiedAt - a.modifiedAt);
|
|
}
|
|
|
|
/**
|
|
* Get files matching a path pattern
|
|
*/
|
|
export function getFilesByPath(pathPattern: string): FSNode[] {
|
|
const pattern = normalizePath(pathPattern);
|
|
|
|
return Array.from(state.nodes.values())
|
|
.filter(node => node.type === 'file' && node.path.startsWith(pattern))
|
|
.sort((a, b) => b.modifiedAt - a.modifiedAt);
|
|
}
|
|
|
|
/**
|
|
* Search files by name
|
|
*/
|
|
export function searchFiles(query: string, options?: {
|
|
path?: string;
|
|
mimeType?: string;
|
|
type?: 'file' | 'directory';
|
|
}): FSNode[] {
|
|
const lowerQuery = query.toLowerCase();
|
|
|
|
return Array.from(state.nodes.values()).filter(node => {
|
|
if (options?.type && node.type !== options.type) return false;
|
|
if (options?.mimeType && !node.mimeType?.startsWith(options.mimeType)) return false;
|
|
if (options?.path && !node.path.startsWith(options.path)) return false;
|
|
return node.name.toLowerCase().includes(lowerQuery);
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Public API - Write Operations
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Create a directory
|
|
*/
|
|
export async function createDirectory(path: string): Promise<FSNode> {
|
|
const node = ensureDirectorySync(normalizePath(path));
|
|
if (!node) {
|
|
throw new Error(`[FileSystem] Cannot create directory: path exists and is not a directory: ${path}`);
|
|
}
|
|
await saveMetadataToDB(node);
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Write a file
|
|
*/
|
|
export async function writeFile(
|
|
path: string,
|
|
content: Blob | ArrayBuffer | string,
|
|
options?: { mimeType?: string; createdAt?: number; modifiedAt?: number }
|
|
): Promise<FSNode> {
|
|
const normalPath = normalizePath(path);
|
|
const parentPath = getParentPath(normalPath);
|
|
const fileName = getFileName(normalPath);
|
|
|
|
// Ensure parent directory exists
|
|
await createDirectory(parentPath);
|
|
|
|
// Convert to Blob
|
|
const blob = content instanceof Blob
|
|
? content
|
|
: new Blob([content], { type: options?.mimeType || 'application/octet-stream' });
|
|
|
|
const now = TimeService.now();
|
|
const createdAt = Number.isFinite(options?.createdAt) ? Number(options?.createdAt) : now;
|
|
const modifiedAt = Number.isFinite(options?.modifiedAt) ? Number(options?.modifiedAt) : now;
|
|
|
|
// Check if file already exists
|
|
let node = getNode(normalPath);
|
|
|
|
if (node && node.type !== 'file') {
|
|
throw new Error(`[FileSystem] Cannot write file: path exists and is a directory: ${normalPath}`);
|
|
}
|
|
|
|
if (node && node.type === 'file') {
|
|
// Update existing file
|
|
node.size = blob.size;
|
|
node.modifiedAt = modifiedAt;
|
|
if (Number.isFinite(options?.createdAt)) node.createdAt = createdAt;
|
|
node.storage = 'indexeddb';
|
|
if (options?.mimeType) node.mimeType = options.mimeType;
|
|
} else {
|
|
// Create new file
|
|
const parentId = state.pathIndex.get(parentPath)!;
|
|
node = {
|
|
id: `file_${now}_${Math.random().toString(36).slice(2, 8)}`,
|
|
name: fileName,
|
|
type: 'file',
|
|
parentId,
|
|
path: normalPath,
|
|
size: blob.size,
|
|
mimeType: options?.mimeType || blob.type,
|
|
createdAt,
|
|
modifiedAt,
|
|
storage: 'indexeddb',
|
|
};
|
|
state.nodes.set(node.id, node);
|
|
state.pathIndex.set(normalPath, node.id);
|
|
}
|
|
|
|
// Save to IndexedDB
|
|
await saveFileToDB(node.id, blob);
|
|
await saveMetadataToDB(node);
|
|
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Editable file metadata — the descriptive fields a caller may safely patch
|
|
* without breaking filesystem invariants. Structural fields (id/path/name/
|
|
* parentId/type) are excluded because changing them is a move/rename (use
|
|
* ``moveNode``); derived/internal fields (size/storage) are excluded because
|
|
* they must stay in sync with the actual blob and storage backend (use
|
|
* ``writeFile`` to change content).
|
|
*/
|
|
export type EditableMetadata = Partial<Pick<FSNode,
|
|
'createdAt' | 'modifiedAt' | 'mimeType' |
|
|
'thumbnailUri' | 'width' | 'height' | 'duration'
|
|
>>;
|
|
|
|
/**
|
|
* Patch a file's editable metadata in place without touching its blob or
|
|
* storage backend. Unlike ``writeFile``, this does not fetch/rewrite content,
|
|
* does not migrate ``preset`` files into IndexedDB, and works even when the
|
|
* file's blob is unavailable — it only mutates node metadata.
|
|
*
|
|
* Returns the updated node, or null if the path doesn't exist or isn't a file.
|
|
*/
|
|
export async function setMetadata(
|
|
path: string,
|
|
patch: EditableMetadata,
|
|
): Promise<FSNode | null> {
|
|
const node = getNode(path);
|
|
if (!node || node.type !== 'file') return null;
|
|
|
|
const keys: (keyof EditableMetadata)[] = [
|
|
'createdAt', 'modifiedAt', 'mimeType',
|
|
'thumbnailUri', 'width', 'height', 'duration',
|
|
];
|
|
for (const key of keys) {
|
|
const value = patch[key];
|
|
if (value !== undefined) {
|
|
(node as unknown as Record<string, unknown>)[key] = value;
|
|
}
|
|
}
|
|
|
|
await saveMetadataToDB(node);
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Delete a file or directory
|
|
*/
|
|
export async function deleteNode(path: string): Promise<boolean> {
|
|
const node = getNode(path);
|
|
if (!node) return false;
|
|
|
|
if (node.type === 'directory') {
|
|
// Recursively delete children
|
|
const children = listDirectory(path);
|
|
for (const child of children) {
|
|
await deleteNode(child.path);
|
|
}
|
|
} else if (node.storage === 'indexeddb') {
|
|
await deleteFileFromDB(node.id);
|
|
}
|
|
// For legacy preset files: remove from metadata only; content is still in public assets
|
|
|
|
// Clear blob URL cache if exists
|
|
clearBlobUrlCache(node.id);
|
|
|
|
state.nodes.delete(node.id);
|
|
state.pathIndex.delete(node.path);
|
|
await deleteMetadataFromDB(node.id);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Move/rename a file or directory
|
|
*/
|
|
export async function moveNode(srcPath: string, destPath: string): Promise<FSNode | null> {
|
|
const normalSrc = normalizePath(srcPath);
|
|
const normalDest = normalizePath(destPath);
|
|
|
|
const node = getNode(normalSrc);
|
|
if (!node) return null;
|
|
|
|
if (normalSrc === normalDest) return node;
|
|
if (exists(normalDest)) return null;
|
|
|
|
const newParentPath = getParentPath(normalDest);
|
|
const newName = getFileName(normalDest);
|
|
|
|
// Ensure destination directory exists
|
|
await createDirectory(newParentPath);
|
|
|
|
const newParentId = state.pathIndex.get(newParentPath);
|
|
if (!newParentId) return null;
|
|
|
|
const now = TimeService.now();
|
|
|
|
// Guard: prevent moving a directory into its own subtree
|
|
if (node.type === 'directory') {
|
|
const srcPrefix = normalSrc === '/' ? '/' : normalSrc + '/';
|
|
if (normalDest.startsWith(srcPrefix)) return null;
|
|
}
|
|
|
|
if (node.type === 'file') {
|
|
state.pathIndex.delete(node.path);
|
|
node.path = normalDest;
|
|
node.name = newName;
|
|
node.parentId = newParentId;
|
|
node.modifiedAt = now;
|
|
state.pathIndex.set(normalDest, node.id);
|
|
await saveMetadataToDB(node);
|
|
return node;
|
|
}
|
|
|
|
// Directory move: update path prefix for all descendants
|
|
const affected: FSNode[] = [];
|
|
const prefix = normalSrc + '/';
|
|
for (const n of state.nodes.values()) {
|
|
if (n.path === normalSrc || n.path.startsWith(prefix)) affected.push(n);
|
|
}
|
|
|
|
// Remove old path index entries
|
|
for (const n of affected) {
|
|
state.pathIndex.delete(n.path);
|
|
}
|
|
|
|
// Update paths
|
|
for (const n of affected) {
|
|
if (n.id === node.id) {
|
|
n.path = normalDest;
|
|
n.name = newName;
|
|
n.parentId = newParentId;
|
|
n.modifiedAt = now;
|
|
} else {
|
|
const suffix = n.path.slice(normalSrc.length);
|
|
n.path = normalDest + suffix;
|
|
n.modifiedAt = now;
|
|
}
|
|
state.pathIndex.set(n.path, n.id);
|
|
}
|
|
|
|
await saveMetadataBatchToDB(affected);
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Copy a file
|
|
*/
|
|
export async function copyFile(srcPath: string, destPath: string): Promise<FSNode | null> {
|
|
const srcNode = getNode(srcPath);
|
|
if (!srcNode || srcNode.type !== 'file') return null;
|
|
|
|
const content = await readFile(srcPath);
|
|
if (!content) return null;
|
|
|
|
return writeFile(destPath, content, { mimeType: srcNode.mimeType });
|
|
}
|
|
|
|
// ============================================================================
|
|
// IndexedDB Operations
|
|
// ============================================================================
|
|
|
|
async function loadMetadataFromDB(): Promise<FSNode[]> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return [];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_METADATA, 'readonly');
|
|
const store = tx.objectStore(STORE_METADATA);
|
|
const request = store.getAll();
|
|
|
|
request.onsuccess = () => resolve(request.result || []);
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function saveMetadataToDB(node: FSNode): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_METADATA, 'readwrite');
|
|
const store = tx.objectStore(STORE_METADATA);
|
|
const request = store.put(node);
|
|
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function deleteMetadataFromDB(id: string): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_METADATA, 'readwrite');
|
|
const store = tx.objectStore(STORE_METADATA);
|
|
const request = store.delete(id);
|
|
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function saveMetadataBatchToDB(nodes: FSNode[]): Promise<void> {
|
|
if (nodes.length === 0) return;
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
const tx = conn.transaction(STORE_METADATA, 'readwrite');
|
|
const store = tx.objectStore(STORE_METADATA);
|
|
for (const node of nodes) store.put(node);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
tx.oncomplete = () => resolve();
|
|
tx.onerror = () => reject(tx.error);
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// System Store (seed marker)
|
|
// ============================================================================
|
|
|
|
async function loadSeedMarkerFromDB(): Promise<SeedMarker | null> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return null;
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_SYSTEM, 'readonly');
|
|
const store = tx.objectStore(STORE_SYSTEM);
|
|
const request = store.get(SEED_MARKER_ID);
|
|
request.onsuccess = () => resolve((request.result as SeedMarker) || null);
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function saveSeedMarkerToDB(marker: SeedMarker): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_SYSTEM, 'readwrite');
|
|
const store = tx.objectStore(STORE_SYSTEM);
|
|
const request = store.put(marker);
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function clearSeedMarkerFromDB(): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_SYSTEM, 'readwrite');
|
|
const store = tx.objectStore(STORE_SYSTEM);
|
|
const request = store.delete(SEED_MARKER_ID);
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function persistAllMetadata(): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
const tx = conn.transaction(STORE_METADATA, 'readwrite');
|
|
const store = tx.objectStore(STORE_METADATA);
|
|
|
|
for (const node of state.nodes.values()) {
|
|
store.put(node);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
tx.oncomplete = () => resolve();
|
|
tx.onerror = () => reject(tx.error);
|
|
});
|
|
}
|
|
|
|
async function saveFileToDB(id: string, content: Blob): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_FILES, 'readwrite');
|
|
const store = tx.objectStore(STORE_FILES);
|
|
const request = store.put({ id, content });
|
|
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function loadFileFromDB(id: string): Promise<Blob | null> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return null;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_FILES, 'readonly');
|
|
const store = tx.objectStore(STORE_FILES);
|
|
const request = store.get(id);
|
|
|
|
request.onsuccess = () => {
|
|
const result = request.result;
|
|
resolve(result?.content || null);
|
|
};
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
async function deleteFileFromDB(id: string): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const tx = conn.transaction(STORE_FILES, 'readwrite');
|
|
const store = tx.objectStore(STORE_FILES);
|
|
const request = store.delete(id);
|
|
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Seed Import (public/sdcard -> IndexedDB)
|
|
// ============================================================================
|
|
|
|
function inferCreatedAtFromName(fileName: string, fallback: number): number {
|
|
const dateMatch = fileName.match(/(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})(\d{2})/);
|
|
if (!dateMatch) return fallback;
|
|
const ts = TimeService.parseToTimestamp(
|
|
`${dateMatch[1]}-${dateMatch[2]}-${dateMatch[3]}T${dateMatch[4]}:${dateMatch[5]}:${dateMatch[6]}`,
|
|
);
|
|
return Number.isFinite(ts) ? ts : fallback;
|
|
}
|
|
|
|
function makeSeedFileId(path: string): string {
|
|
// Stable across runs (within one DB lifecycle). OK that it changes after reset.
|
|
return `seed_${normalizePath(path).replace(/\//g, '_')}`;
|
|
}
|
|
|
|
async function clearFilesAndMetadataStores(): Promise<void> {
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
const tx = conn.transaction([STORE_METADATA, STORE_FILES], 'readwrite');
|
|
tx.objectStore(STORE_METADATA).clear();
|
|
tx.objectStore(STORE_FILES).clear();
|
|
await new Promise<void>((resolve, reject) => {
|
|
tx.oncomplete = () => resolve();
|
|
tx.onerror = () => reject(tx.error);
|
|
});
|
|
}
|
|
|
|
async function seedImportFromPublicSdcard(): Promise<void> {
|
|
if (!(await ensureDb())) return;
|
|
|
|
console.log('[FileSystem] Seed import: start');
|
|
|
|
// Clean slate
|
|
await clearFilesAndMetadataStores();
|
|
blobUrlCache.forEach((url) => URL.revokeObjectURL(url));
|
|
blobUrlCache.clear();
|
|
|
|
await saveSeedMarkerToDB({
|
|
id: SEED_MARKER_ID,
|
|
version: SEED_SCHEMA_VERSION,
|
|
status: 'in_progress',
|
|
importedAt: TimeService.now(),
|
|
source: 'public/sdcard',
|
|
});
|
|
|
|
// Build base structure in memory first
|
|
await createBaseStateInMemory();
|
|
|
|
const scan = await scanSdcard();
|
|
if (scan) {
|
|
for (const dir of scan.directories) ensureDirectorySync(dir.path);
|
|
|
|
// Build metadata + collect items for batched fetching
|
|
const fetchItems: { id: string; uri: string; node: FSNode }[] = [];
|
|
|
|
for (const file of scan.files) {
|
|
const normalPath = normalizePath(file.path);
|
|
const parentPath = getParentPath(normalPath);
|
|
ensureDirectorySync(parentPath);
|
|
|
|
const parentId = state.pathIndex.get(parentPath);
|
|
if (!parentId) continue;
|
|
|
|
const modifiedAt = file.modifiedAt || TimeService.now();
|
|
const createdAt = inferCreatedAtFromName(file.name, modifiedAt);
|
|
const id = makeSeedFileId(normalPath);
|
|
|
|
const node: FSNode = {
|
|
id,
|
|
name: file.name,
|
|
type: 'file',
|
|
parentId,
|
|
path: normalPath,
|
|
size: file.size,
|
|
mimeType: file.mimeType,
|
|
createdAt,
|
|
modifiedAt,
|
|
storage: 'indexeddb',
|
|
};
|
|
|
|
state.nodes.set(node.id, node);
|
|
state.pathIndex.set(node.path, node.id);
|
|
|
|
fetchItems.push({ id, uri: file.uri || normalPath, node });
|
|
}
|
|
|
|
// Fetch in batches of 8 to avoid TCP connection storms under high concurrency
|
|
const SEED_FETCH_BATCH = 8;
|
|
const fetched: { id: string; blob: Blob }[] = [];
|
|
for (let i = 0; i < fetchItems.length; i += SEED_FETCH_BATCH) {
|
|
const batch = fetchItems.slice(i, i + SEED_FETCH_BATCH);
|
|
const results = await Promise.all(batch.map(({ id, uri, node }) =>
|
|
fetch(presetAssetUrl(uri)).then(async (resp) => {
|
|
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
|
|
const blob = await resp.blob();
|
|
node.size = blob.size;
|
|
node.mimeType = node.mimeType || blob.type;
|
|
return { id, blob } as { id: string; blob: Blob };
|
|
}).catch((e) => {
|
|
console.warn('[FileSystem] Seed import: failed to fetch file', uri, e);
|
|
return null;
|
|
}),
|
|
));
|
|
for (const r of results) if (r) fetched.push(r);
|
|
}
|
|
|
|
if (fetched.length > 0) {
|
|
const conn = await ensureDb();
|
|
if (conn) {
|
|
const tx = conn.transaction(STORE_FILES, 'readwrite');
|
|
const store = tx.objectStore(STORE_FILES);
|
|
for (const { id, blob } of fetched) {
|
|
store.put({ id, content: blob });
|
|
}
|
|
await new Promise<void>((resolve, reject) => {
|
|
tx.oncomplete = () => resolve();
|
|
tx.onerror = () => reject(tx.error);
|
|
});
|
|
}
|
|
}
|
|
} else if (FILE_SYSTEM_CONFIG.presetFiles.length > 0) {
|
|
console.log('[FileSystem] Seed import: scan API unavailable, fallback to config presetFiles');
|
|
for (const preset of FILE_SYSTEM_CONFIG.presetFiles) {
|
|
await importPresetFileFromConfig(preset);
|
|
}
|
|
} else {
|
|
console.warn('[FileSystem] Seed import: no scan API and no presetFiles; created empty /sdcard');
|
|
}
|
|
|
|
// Persist all metadata at once (directories + files + root)
|
|
await persistAllMetadata();
|
|
|
|
await saveSeedMarkerToDB({
|
|
id: SEED_MARKER_ID,
|
|
version: SEED_SCHEMA_VERSION,
|
|
status: 'complete',
|
|
importedAt: TimeService.now(),
|
|
source: scan ? 'public/sdcard' : (FILE_SYSTEM_CONFIG.presetFiles.length > 0 ? 'config' : 'none'),
|
|
});
|
|
|
|
console.log('[FileSystem] Seed import: complete');
|
|
}
|
|
|
|
async function importPresetFileFromConfig(preset: PresetFile): Promise<void> {
|
|
const normalPath = normalizePath(preset.path);
|
|
const parentPath = getParentPath(normalPath);
|
|
ensureDirectorySync(parentPath);
|
|
const parentId = state.pathIndex.get(parentPath);
|
|
if (!parentId) return;
|
|
|
|
const fileName = getFileName(normalPath);
|
|
const now = TimeService.now();
|
|
const createdAt = inferCreatedAtFromName(fileName, now);
|
|
const id = makeSeedFileId(normalPath);
|
|
|
|
const node: FSNode = {
|
|
id,
|
|
name: fileName,
|
|
type: 'file',
|
|
parentId,
|
|
path: normalPath,
|
|
size: preset.size,
|
|
mimeType: preset.mimeType,
|
|
createdAt,
|
|
modifiedAt: createdAt,
|
|
storage: 'indexeddb',
|
|
width: preset.width,
|
|
height: preset.height,
|
|
duration: preset.duration,
|
|
};
|
|
|
|
state.nodes.set(node.id, node);
|
|
state.pathIndex.set(node.path, node.id);
|
|
|
|
try {
|
|
const resp = await fetch(presetAssetUrl(preset.uri));
|
|
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
|
|
const blob = await resp.blob();
|
|
node.size = blob.size;
|
|
node.mimeType = node.mimeType || blob.type;
|
|
await saveFileToDB(node.id, blob);
|
|
} catch (e) {
|
|
console.warn('[FileSystem] Seed import (config): failed to fetch preset', preset.path, e);
|
|
}
|
|
}
|
|
|
|
async function migrateLegacyPresetNodesToIndexedDB(nodes: FSNode[]): Promise<void> {
|
|
if (!(await ensureDb())) return;
|
|
|
|
console.log('[FileSystem] Legacy migration: converting preset nodes to indexeddb');
|
|
|
|
// Restore to memory to reuse helpers and keep pathIndex consistent
|
|
state.nodes = new Map(nodes.map((n) => [n.id, n]));
|
|
state.pathIndex = new Map(nodes.map((n) => [n.path, n.id]));
|
|
|
|
for (const node of state.nodes.values()) {
|
|
if (node.type !== 'file') continue;
|
|
if (node.storage !== 'preset') continue;
|
|
|
|
try {
|
|
const resp = await fetch(node.path);
|
|
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
|
|
const blob = await resp.blob();
|
|
await saveFileToDB(node.id, blob);
|
|
node.storage = 'indexeddb';
|
|
node.size = blob.size;
|
|
node.mimeType = node.mimeType || blob.type;
|
|
} catch (e) {
|
|
console.warn('[FileSystem] Legacy migration: failed to migrate', node.path, e);
|
|
}
|
|
}
|
|
|
|
await persistAllMetadata();
|
|
}
|
|
|
|
async function ensureSeedImportedIfNeeded(): Promise<void> {
|
|
if (!(await ensureDb())) return;
|
|
|
|
const marker = await loadSeedMarkerFromDB();
|
|
if (marker?.status === 'complete') {
|
|
if (marker.version !== SEED_SCHEMA_VERSION) {
|
|
console.warn('[FileSystem] Seed schema changed, re-importing');
|
|
await seedImportFromPublicSdcard();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If import was interrupted, restart from scratch
|
|
if (marker?.status === 'in_progress') {
|
|
console.warn('[FileSystem] Seed marker in_progress, re-importing');
|
|
await seedImportFromPublicSdcard();
|
|
return;
|
|
}
|
|
|
|
// Backward compatibility: older DB might exist without marker
|
|
const existingNodes = await loadMetadataFromDB();
|
|
if (existingNodes.length > 0) {
|
|
const hasPreset = existingNodes.some((n) => n.type === 'file' && n.storage === 'preset');
|
|
await saveSeedMarkerToDB({
|
|
id: SEED_MARKER_ID,
|
|
version: SEED_SCHEMA_VERSION,
|
|
status: 'in_progress',
|
|
importedAt: TimeService.now(),
|
|
source: 'legacy_migration',
|
|
note: hasPreset ? 'migrating preset nodes' : 'marker added to existing db',
|
|
});
|
|
|
|
if (hasPreset) {
|
|
await migrateLegacyPresetNodesToIndexedDB(existingNodes);
|
|
}
|
|
|
|
await saveSeedMarkerToDB({
|
|
id: SEED_MARKER_ID,
|
|
version: SEED_SCHEMA_VERSION,
|
|
status: 'complete',
|
|
importedAt: TimeService.now(),
|
|
source: 'legacy_migration',
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Fresh DB
|
|
await seedImportFromPublicSdcard();
|
|
}
|
|
|
|
// ============================================================================
|
|
// Utility Functions
|
|
// ============================================================================
|
|
|
|
function normalizePath(path: string): string {
|
|
// Remove trailing slashes and normalize multiple slashes
|
|
return path.replace(/\/+/g, '/').replace(/\/$/, '') || '/';
|
|
}
|
|
|
|
function getParentPath(path: string): string {
|
|
const parts = path.split('/').filter(Boolean);
|
|
parts.pop();
|
|
return '/' + parts.join('/');
|
|
}
|
|
|
|
function getFileName(path: string): string {
|
|
return path.split('/').filter(Boolean).pop() || '';
|
|
}
|
|
|
|
/**
|
|
* Format file size for display
|
|
*/
|
|
export function formatFileSize(bytes: number): string {
|
|
if (bytes < 1024) return bytes + ' B';
|
|
if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
|
|
if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
|
|
return (bytes / (1024 * 1024 * 1024)).toFixed(1) + ' GB';
|
|
}
|
|
|
|
/**
|
|
* Get display name for a directory
|
|
*/
|
|
export function getDirectoryDisplayName(path: string): string {
|
|
const preset = FILE_SYSTEM_CONFIG.presetStructure.find(d => d.path === path);
|
|
return preset?.displayName || getFileName(path);
|
|
}
|
|
|
|
export function snapshotFileSystem(): { nodes: Omit<FSNode, 'thumbnailUri'>[] } {
|
|
const nodes = Array.from(state.nodes.values())
|
|
.map((node) => {
|
|
const { thumbnailUri, ...meta } = node;
|
|
return meta;
|
|
})
|
|
.sort((a, b) => a.path.localeCompare(b.path));
|
|
return { nodes };
|
|
}
|
|
|
|
function clearRuntimeState(): void {
|
|
state.nodes.clear();
|
|
state.pathIndex.clear();
|
|
state.initialized = false;
|
|
initPromise = null;
|
|
blobUrlCache.forEach((url) => URL.revokeObjectURL(url));
|
|
blobUrlCache.clear();
|
|
}
|
|
|
|
/**
|
|
* Clear all data from IndexedDB stores without deleting the database.
|
|
* Uses the existing connection — avoids 'deleteDatabase blocked' when
|
|
* transactions (e.g. seed import) are still in-flight.
|
|
* After clearing, the next initFileSystem() will re-seed from scratch.
|
|
*/
|
|
export async function clearFileSystemDB(): Promise<void> {
|
|
clearRuntimeState();
|
|
|
|
const conn = await ensureDb();
|
|
if (!conn) return;
|
|
|
|
const storeNames = [STORE_FILES, STORE_METADATA, STORE_SYSTEM].filter(
|
|
name => conn.objectStoreNames.contains(name),
|
|
);
|
|
if (storeNames.length === 0) return;
|
|
|
|
const tx = conn.transaction(storeNames, 'readwrite');
|
|
for (const name of storeNames) {
|
|
tx.objectStore(name).clear();
|
|
}
|
|
await new Promise<void>((resolve, reject) => {
|
|
tx.oncomplete = () => resolve();
|
|
tx.onerror = () => reject(tx.error);
|
|
});
|
|
}
|
|
|
|
export async function destroyFileSystemDB(): Promise<void> {
|
|
if (db && !dbClosed) {
|
|
db.close();
|
|
dbClosed = true;
|
|
}
|
|
db = null;
|
|
|
|
clearRuntimeState();
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
const request = indexedDB.deleteDatabase(DB_NAME);
|
|
request.onsuccess = () => resolve();
|
|
request.onerror = () => reject(request.error ?? new Error('deleteDatabase failed'));
|
|
request.onblocked = () => reject(new Error('deleteDatabase blocked'));
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Agent API
|
|
// ============================================================================
|
|
|
|
/**
|
|
* 刷新文件系统
|
|
*
|
|
* V2 语义：运行时不再扫描/合并 public/sdcard，预置内容更新统一通过 reset 完成。
|
|
*/
|
|
export async function refreshFileSystem(): Promise<void> {
|
|
console.warn('[FileSystem] refresh() is deprecated. Use __SIM_FS__.reset() to re-import from public/sdcard.');
|
|
}
|
|
|
|
/**
|
|
* 重置文件系统（清除 IndexedDB 并重新创建）
|
|
* 用于开发调试
|
|
*/
|
|
export async function resetFileSystem(): Promise<void> {
|
|
console.log('[FileSystem] Resetting...');
|
|
|
|
const conn = await ensureDb();
|
|
if (!conn) {
|
|
console.error('[FileSystem] Reset failed to open DB');
|
|
await createBaseStateInMemory();
|
|
return;
|
|
}
|
|
|
|
await clearSeedMarkerFromDB();
|
|
await seedImportFromPublicSdcard();
|
|
|
|
console.log('[FileSystem] Reset complete, now has', state.nodes.size, 'nodes');
|
|
}
|
|
|
|
function exposeAgentAPI(): void {
|
|
window.__SIM_FS__ = {
|
|
// Directory operations
|
|
list: listDirectory,
|
|
mkdir: createDirectory,
|
|
|
|
// File operations
|
|
read: readFile,
|
|
write: writeFile,
|
|
setMetadata,
|
|
delete: deleteNode,
|
|
move: moveNode,
|
|
copy: copyFile,
|
|
|
|
// Query
|
|
stat: getNode,
|
|
exists,
|
|
search: searchFiles,
|
|
getMedia: getMediaFiles,
|
|
getByPath: getFilesByPath,
|
|
|
|
// Utils
|
|
getUri: getFileUri,
|
|
getUriAsync: getFileUriAsync,
|
|
formatSize: formatFileSize,
|
|
getDisplayName: getDirectoryDisplayName,
|
|
|
|
// Refresh & Reset
|
|
refresh: refreshFileSystem,
|
|
reset: resetFileSystem,
|
|
};
|
|
}
|