@hienlh/ppm 0.17.56 → 0.18.0

package/src/server/routes/files.ts

@@ -2,7 +2,7 @@ import { Hono } from "hono";
 import { resolve, isAbsolute } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { fileService, SecurityError, NotFoundError, ValidationError } from "../../services/file.service.ts";
-import { readSystemFile } from "../../services/fs-browse.service.ts";
+import { readSystemFileSync } from "../../services/fs-browse.service.ts";
 import { ok, err } from "../../types/api.ts";
 import { errorStatus } from "../helpers/error-status.ts";
 import mammoth from "mammoth";
@@ -243,7 +243,7 @@ fileRoutes.get("/compare", (c) => {
     }
     // Support absolute paths (files outside project, e.g. /tmp/)
     const readSide = (p: string) =>
-      isAbsolute(p) ? readSystemFile(p).content : fileService.readFile(projectPath, p).content;
+      isAbsolute(p) ? readSystemFileSync(p).content : fileService.readFile(projectPath, p).content;
     const original = readSide(file1);
     const modified = readSide(file2);
     return c.json(ok({ original, modified }));

package/src/server/routes/fs-browse.ts

@@ -1,103 +1,139 @@
 import { Hono } from "hono";
-import { existsSync, mkdirSync, realpathSync, rmSync, statSync } from "fs";
-import { resolve } from "path";
-import { $ } from "bun";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
 import mammoth from "mammoth";
+import { browse } from "../../services/fs-browse.service.ts";
+import { list } from "../../services/fs-ops/fs-list-files.service.ts";
 import {
-  browse,
-  list,
-  readSystemFile,
-  writeSystemFile,
+  assertAllowed,
+  assertNotPpmDir,
   isAllowedPath,
   resolvePath,
-} from "../../services/fs-browse.service.ts";
+} from "../../services/fs-path-guard.service.ts";
+import {
+  readSystemFile,
+  realPathOrSelf,
+  writeSystemFile,
+} from "../../services/fs-ops/fs-ops-read-write.service.ts";
+import { makeDir } from "../../services/fs-ops/fs-ops-mutate.service.ts";
+import { runGitInit } from "../../services/fs-ops/fs-git-init.service.ts";
+import { attachmentDisposition } from "../../services/fs-ops/fs-content-disposition.ts";
+import { fsErrorBody } from "../../services/fs-ops/fs-error-response.ts";
 import { isImageExtension } from "../../shared/image-extensions.ts";
 import { ok, err } from "../../types/api.ts";
-import { createDownloadToken } from "../../services/download-token.service.ts";
+import {
+  createDownloadToken,
+  consumeDownloadToken,
+} from "../../services/download-token.service.ts";
 
 export const fsBrowseRoutes = new Hono();
 
-/** Map error to HTTP status (errors carry .status from service). */
-function errorStatus(e: unknown): 400 | 403 | 404 | 500 {
-  const status = (e as { status?: number }).status;
-  if (status === 403 || status === 404 || status === 400) return status;
-  return 500;
+function fail(e: unknown) {
+  return fsErrorBody(e);
 }
 
 /** GET /api/fs/browse?path=/some/dir&showHidden=false */
-fsBrowseRoutes.get("/browse", (c) => {
+fsBrowseRoutes.get("/browse", async (c) => {
   try {
     const path = c.req.query("path") || undefined;
     const showHidden = c.req.query("showHidden") === "true";
-    const result = browse(path, { showHidden });
-    return c.json(ok(result));
+    return c.json(ok(await browse(path, { showHidden })));
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
 /** GET /api/fs/list?dir=/some/dir — recursive file listing (command palette) */
-fsBrowseRoutes.get("/list", (c) => {
+fsBrowseRoutes.get("/list", async (c) => {
   try {
     const dir = c.req.query("dir");
     if (!dir) return c.json(err("dir is required"), 400);
-    const files = list(dir);
-    return c.json(ok(files));
+    return c.json(ok(await list(dir)));
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
 /** GET /api/fs/read?path=/some/file — read file outside project */
-fsBrowseRoutes.get("/read", (c) => {
+fsBrowseRoutes.get("/read", async (c) => {
   try {
     const filePath = c.req.query("path");
     if (!filePath) return c.json(err("path is required"), 400);
-    const result = readSystemFile(filePath);
-    return c.json(ok(result));
+    return c.json(ok(await readSystemFile(filePath)));
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
-/** POST /api/fs/download/token — generate a short-lived token for external file downloads */
-fsBrowseRoutes.post("/download/token", (c) => {
-  const token = createDownloadToken();
-  return c.json(ok({ token }));
+/**
+ * POST /api/fs/download/token — body: { path }
+ * The token is bound to that one file and spent on first use, so a URL that
+ * leaks through history or a proxy log cannot fetch anything else.
+ */
+fsBrowseRoutes.post("/download/token", async (c) => {
+  try {
+    const body = await c.req.json<{ path?: string }>().catch(() => ({}) as { path?: string });
+    if (!body.path) return c.json(err("path is required"), 400);
+    const resolved = resolvePath(body.path);
+    assertAllowed(resolved);
+    assertNotPpmDir(resolved);
+    assertNotPpmDir(await realPathOrSelf(resolved));
+    return c.json(ok({ token: createDownloadToken(resolved) }));
+  } catch (e) {
+    const { body, status } = fail(e);
+    return c.json(body, status);
+  }
 });
 
-/** GET /api/fs/raw?path=/some/file — serve file as binary (for images in markdown, etc.) */
-fsBrowseRoutes.get("/raw", (c) => {
+/** GET /api/fs/raw?path=/some/file — serve file as binary (images, downloads) */
+fsBrowseRoutes.get("/raw", async (c) => {
   try {
     const filePath = c.req.query("path");
     if (!filePath) return c.json(err("path is required"), 400);
 
     const resolved = resolvePath(filePath);
+    const real = await realPathOrSelf(resolved);
     // Images are streamed even from outside the browse whitelist: the chat UI renders images
     // the assistant just read, and those live at arbitrary paths. Limiting the exception to
     // image extensions stops it from becoming an arbitrary-file read. The extension is
     // re-checked after resolving symlinks, so a link named *.png cannot hand out a
     // non-image target.
     if (!isAllowedPath(resolved)) {
-      const target = existsSync(resolved) ? realpathSync(resolved) : resolved;
-      if (!isImageExtension(resolved) || !isImageExtension(target)) {
+      if (!isImageExtension(resolved) || !isImageExtension(real)) {
         return c.json(err("Access denied"), 403);
       }
     }
-    if (!existsSync(resolved)) return c.json(err("File not found"), 404);
+    assertNotPpmDir(resolved);
+    assertNotPpmDir(real);
+
+    // A download token authenticated this request in place of the session, so
+    // it must match the file being served and is spent here.
+    const dlToken = c.req.query("dl_token");
+    if (dlToken && !consumeDownloadToken(dlToken, resolved)) {
+      return c.json(err("Download token invalid for this path"), 403);
+    }
+
+    const info = await stat(resolved).catch(() => null);
+    if (!info) return c.json(err("File not found"), 404);
 
     const download = c.req.query("download") === "true";
-    const filename = resolved.split("/").pop() ?? "download";
+    const filename = basename(resolved) || "download";
     const file = Bun.file(resolved);
     return new Response(file.stream(), {
       headers: {
         "Content-Type": download ? "application/octet-stream" : (file.type || "application/octet-stream"),
-        "Content-Disposition": download ? `attachment; filename="${filename}"` : "inline",
-        "Cache-Control": "private, max-age=3600",
+        "Content-Disposition": download ? attachmentDisposition(filename) : "inline",
+        // A download is a one-shot transfer of a file the user may edit right
+        // after; caching it would hand out stale bytes on the next download.
+        "Cache-Control": download ? "no-store" : "private, max-age=3600",
       },
     });
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
@@ -106,63 +142,52 @@ fsBrowseRoutes.get("/docx-html", async (c) => {
   try {
     const filePath = c.req.query("path");
     if (!filePath) return c.json(err("path is required"), 400);
-    if (!existsSync(filePath)) return c.json(err("File not found"), 404);
+    const resolved = resolvePath(filePath);
+    assertAllowed(resolved);
+    assertNotPpmDir(resolved);
+    assertNotPpmDir(await realPathOrSelf(resolved));
+    if (!(await stat(resolved).catch(() => null))) return c.json(err("File not found"), 404);
 
-    const arrayBuf = await Bun.file(filePath).arrayBuffer();
+    const arrayBuf = await Bun.file(resolved).arrayBuffer();
     const result = await mammoth.convertToHtml({ buffer: Buffer.from(arrayBuf) });
     return c.json(ok({ html: result.value, warnings: result.messages }));
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
-/** DELETE /api/fs/rmdir — delete a directory { path } */
-fsBrowseRoutes.delete("/rmdir", async (c) => {
-  try {
-    const body = await c.req.json<{ path: string }>();
-    if (!body.path) return c.json(err("path is required"), 400);
-
-    const abs = resolve(body.path);
-    if (!existsSync(abs)) return c.json(err("Directory not found"), 404);
-    if (!statSync(abs).isDirectory()) return c.json(err("Path is not a directory"), 400);
-
-    rmSync(abs, { recursive: true });
-    return c.json(ok({ removed: abs }));
-  } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
-  }
-});
-
-/** POST /api/fs/mkdir — create directory and git init { path } */
+/**
+ * POST /api/fs/mkdir — create directory { path, gitInit? }
+ * `gitInit` defaults to true because the project picker uses this route to
+ * create new project folders; the explorer passes false.
+ */
 fsBrowseRoutes.post("/mkdir", async (c) => {
   try {
-    const body = await c.req.json<{ path: string }>();
+    const body = await c.req.json<{ path?: string; gitInit?: boolean }>();
     if (!body.path) return c.json(err("path is required"), 400);
 
-    const abs = resolve(body.path);
-    if (existsSync(abs)) {
-      return c.json(err(`Directory already exists: ${abs}`), 400);
-    }
-
-    mkdirSync(abs, { recursive: true });
-    // git init in the new directory
-    await $`git init ${abs}`.quiet();
-    return c.json(ok({ path: abs, gitInitialized: true }), 201);
+    const { path } = await makeDir(body.path);
+    const gitInit = body.gitInit !== false;
+    if (gitInit) await runGitInit(path);
+    return c.json(ok({ path, gitInitialized: gitInit }), 201);
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });
 
 /** PUT /api/fs/write — write file outside project { path, content } */
 fsBrowseRoutes.put("/write", async (c) => {
   try {
-    const body = await c.req.json<{ path: string; content: string }>();
+    const body = await c.req.json<{ path?: string; content?: string }>();
     if (!body.path || body.content == null) {
       return c.json(err("path and content required"), 400);
     }
-    writeSystemFile(body.path, body.content);
+    await writeSystemFile(body.path, body.content);
     return c.json(ok(true));
   } catch (e) {
-    return c.json(err((e as Error).message), errorStatus(e));
+    const { body, status } = fail(e);
+    return c.json(body, status);
   }
 });

package/src/server/routes/fs-ops.ts

@@ -0,0 +1,118 @@
+import { Hono, type Context } from "hono";
+import { ok, err } from "../../types/api.ts";
+import { fsErrorBody } from "../../services/fs-ops/fs-error-response.ts";
+import { statPath } from "../../services/fs-ops/fs-ops-stat.service.ts";
+import { copyPath, movePath } from "../../services/fs-ops/fs-ops-copy-move.service.ts";
+import {
+  deletePath,
+  makeDir,
+  renamePath,
+  touchFile,
+} from "../../services/fs-ops/fs-ops-mutate.service.ts";
+import { trashPath } from "../../services/fs-ops/fs-ops-trash.service.ts";
+
+/**
+ * Out-of-project filesystem mutations for the explorer. Mounted on the same
+ * `/api/fs` prefix as the browse routes; every handler resolves and whitelists
+ * its paths inside the service layer and reports failures through one mapper
+ * so the client always gets `{ error, code }`.
+ *
+ * Path contract for `/copy` and `/move`: `destination` is the FULL target
+ * path. Dropping an entry onto a folder is a client-side compose —
+ * `join(targetDir, basename(source))` — because a destination that already
+ * exists (a folder included) answers 409 EEXIST rather than merging.
+ */
+export const fsOpsRoutes = new Hono();
+
+function fail(c: Context, e: unknown) {
+  const { body, status } = fsErrorBody(e);
+  return c.json(body, status);
+}
+
+/** GET /api/fs/stat?path=... */
+fsOpsRoutes.get("/stat", async (c) => {
+  try {
+    const path = c.req.query("path");
+    if (!path) return c.json(err("path is required"), 400);
+    return c.json(ok(await statPath(path)));
+  } catch (e) {
+    return fail(c, e);
+  }
+});
+
+/** POST /api/fs/copy — body: { source, destination } (destination = full target path) */
+fsOpsRoutes.post("/copy", async (c) => {
+  try {
+    const body = await c.req.json<{ source?: string; destination?: string }>();
+    if (!body.source || !body.destination) {
+      return c.json(err("source and destination are required"), 400);
+    }
+    return c.json(ok(await copyPath(body.source, body.destination)));
+  } catch (e) {
+    return fail(c, e);
+  }
+});
+
+/** POST /api/fs/move — body: { source, destination } (destination = full target path) */
+fsOpsRoutes.post("/move", async (c) => {
+  try {
+    const body = await c.req.json<{ source?: string; destination?: string }>();
+    if (!body.source || !body.destination) {
+      return c.json(err("source and destination are required"), 400);
+    }
+    return c.json(ok(await movePath(body.source, body.destination)));
+  } catch (e) {
+    return fail(c, e);
+  }
+});
+
+/** POST /api/fs/rename — body: { path, newName } */
+fsOpsRoutes.post("/rename", async (c) => {
+  try {
+    const body = await c.req.json<{ path?: string; newName?: string }>();
+    if (!body.path || !body.newName) {
+      return c.json(err("path and newName are required"), 400);
+    }
+    return c.json(ok(await renamePath(body.path, body.newName)));
+  } catch (e) {
+    return fail(c, e);
+  }
+});
+
+/** POST /api/fs/touch — body: { path } */
+fsOpsRoutes.post("/touch", async (c) => {
+  try {
+    const body = await c.req.json<{ path?: string }>();
+    if (!body.path) return c.json(err("path is required"), 400);
+    return c.json(ok(await touchFile(body.path)), 201);
+  } catch (e) {
+    return fail(c, e);
+  }
+});
+
+/**
+ * DELETE /api/fs/delete — body: { path, permanent?: boolean }
+ * Default is the OS trash so the action stays undoable; when no trash backend
+ * exists the answer is 409 NO_TRASH and the client asks about a hard delete.
+ */
+async function handleDelete(c: Context) {
+  try {
+    type DeleteBody = { path?: string; permanent?: boolean };
+    // A DELETE without a body is a client mistake, not a server error.
+    const body = await c.req.json<DeleteBody>().catch((): DeleteBody => ({}));
+    if (!body.path) return c.json(err("path is required"), 400);
+    if (body.permanent) {
+      const result = await deletePath(body.path);
+      return c.json(ok({ ...result, trashed: false, permanent: true }));
+    }
+    const result = await trashPath(body.path);
+    return c.json(ok({ removed: result.path, trashed: true, permanent: false }));
+  } catch (e) {
+    return fail(c, e);
+  }
+}
+
+fsOpsRoutes.delete("/delete", handleDelete);
+
+/** DELETE /api/fs/rmdir — legacy name kept as an alias of /delete. */
+fsOpsRoutes.delete("/rmdir", handleDelete);

package/src/server/routes/fs-sqlite.ts

@@ -0,0 +1,129 @@
+import { Hono } from "hono";
+import { sqliteService } from "../../services/sqlite.service.ts";
+import { detectOperation } from "../../services/query-audit/query-audit.service.ts";
+import { logQuery, type AuditFields } from "./query-audit-hook.ts";
+import { stat } from "node:fs/promises";
+import {
+  assertAllowed,
+  assertNotPpmSubtreeDeep,
+  resolvePath,
+} from "../../services/fs-path-guard.service.ts";
+import { fsErrorBody } from "../../services/fs-ops/fs-error-response.ts";
+import { ok, err } from "../../types/api.ts";
+
+/**
+ * SQLite viewer for database files outside any project, so a `.db` opened from
+ * the explorer behaves like one inside a project. Paths are absolute and pass
+ * the same guard as every other filesystem route; the PPM directory stays out
+ * of reach because it holds the credentials database.
+ */
+export const fsSqliteRoutes = new Hono();
+
+/**
+ * Guard an absolute db path; the service is addressed with no project root.
+ * The PPM refusal follows symlinks like every other read door, and existence
+ * is probed here — asynchronously — so the service never runs a blocking
+ * `existsSync` against a path the caller chose.
+ */
+async function guardDbPath(input: string): Promise<string> {
+  const resolved = resolvePath(input);
+  assertAllowed(resolved);
+  await assertNotPpmSubtreeDeep(resolved);
+  const info = await stat(resolved);
+  if (!info.isFile()) {
+    throw Object.assign(new Error("Not a database file"), { status: 400, code: "EINVAL" });
+  }
+  return resolved;
+}
+
+/** Row cap for a foreign database of unknown size. */
+const MAX_QUERY_ROWS = 1_000;
+
+/** These routes address a database by file path, so there is no connection id. */
+function fileAudit(dbPath: string): Pick<AuditFields, "connectionId" | "connectionName" | "dbType"> {
+  return { connectionId: null, connectionName: dbPath, dbType: "sqlite" };
+}
+
+function fail(e: unknown) {
+  return fsErrorBody(e);
+}
+
+/** GET /api/fs/sqlite/tables?path=/abs/file.db */
+fsSqliteRoutes.get("/tables", async (c) => {
+  try {
+    const path = c.req.query("path");
+    if (!path) return c.json(err("Missing query parameter: path"), 400);
+    return c.json(ok(sqliteService.getTables("", await guardDbPath(path))));
+  } catch (e) {
+    const { body, status } = fail(e);
+    return c.json(body, status);
+  }
+});
+
+/** GET /api/fs/sqlite/schema?path=...&table=... */
+fsSqliteRoutes.get("/schema", async (c) => {
+  try {
+    const path = c.req.query("path");
+    const table = c.req.query("table");
+    if (!path || !table) return c.json(err("Missing query parameters: path, table"), 400);
+    return c.json(ok(sqliteService.getTableSchema("", await guardDbPath(path), table)));
+  } catch (e) {
+    const { body, status } = fail(e);
+    return c.json(body, status);
+  }
+});
+
+/** GET /api/fs/sqlite/data?path=...&table=...&page=1&limit=100&orderBy=...&orderDir=ASC */
+fsSqliteRoutes.get("/data", async (c) => {
+  try {
+    const path = c.req.query("path");
+    const table = c.req.query("table");
+    if (!path || !table) return c.json(err("Missing query parameters: path, table"), 400);
+    const page = parseInt(c.req.query("page") ?? "1", 10);
+    const limit = Math.min(parseInt(c.req.query("limit") ?? "100", 10), 1000);
+    const orderBy = c.req.query("orderBy");
+    const orderDir = c.req.query("orderDir") === "DESC" ? "DESC" : "ASC";
+    const data = sqliteService.getTableData(
+      "", await guardDbPath(path), table, page, limit, orderBy, orderDir as "ASC" | "DESC",
+    );
+    return c.json(ok(data));
+  } catch (e) {
+    const { body, status } = fail(e);
+    return c.json(body, status);
+  }
+});
+
+/** POST /api/fs/sqlite/query — body: { path, sql } */
+fsSqliteRoutes.post("/query", async (c) => {
+  const startedAt = Date.now();
+  try {
+    const body = await c.req.json<{ path?: string; sql?: string }>();
+    if (!body.path || !body.sql) return c.json(err("Missing required fields: path, sql"), 400);
+    const dbPath = await guardDbPath(body.path);
+
+    const audit = {
+      ...fileAudit(dbPath),
+      source: "editor" as const,
+      operation: detectOperation(body.sql),
+      sql: body.sql,
+    };
+
+    try {
+      const result = sqliteService.executeQuery("", dbPath, body.sql, MAX_QUERY_ROWS);
+      logQuery(c, {
+        ...audit,
+        status: "ok",
+        rows: result.rows,
+        rowCount: result.changeType === "select" ? result.rows.length : result.rowsAffected,
+        durationMs: Date.now() - startedAt,
+      });
+      return c.json(ok(result));
+    } catch (e) {
+      logQuery(c, { ...audit, status: "error", error: (e as Error).message, durationMs: Date.now() - startedAt });
+      throw e;
+    }
+  } catch (e) {
+    const { body, status } = fail(e);
+    return c.json(body, status);
+  }
+});

package/src/server/routes/host-info.ts

@@ -0,0 +1,17 @@
+import { Hono } from "hono";
+import { getHostInfo } from "../../services/host-info/host-info.service.ts";
+import { ok, err } from "../../types/api.ts";
+
+export const hostInfoRoutes = new Hono();
+
+/** GET /host — cached (60s) server facts: platform, drives, known folders, OS-pinned folders.
+ *  `?refresh=true` bypasses the cache. Providers never throw, so this route never 500s on their behalf. */
+hostInfoRoutes.get("/host", async (c) => {
+  const refresh = c.req.query("refresh") === "true";
+  try {
+    const info = await getHostInfo({ refresh });
+    return c.json(ok(info));
+  } catch (e: any) {
+    return c.json(err(`Failed to read host info: ${e?.message ?? e}`), 500);
+  }
+});

package/src/server/routes/settings.ts

@@ -131,6 +131,8 @@ const UI_PREF_VALIDATORS: Record<string, (v: unknown) => boolean> = {
       strList(groups, 200) && strList(tables, 500)
     );
   },
+  // OS Explorer window chrome override — "auto" follows the host platform
+  explorerSkin: (v) => v === "auto" || v === "windows" || v === "macos",
   // Project switcher prefs
   projectSortMode: (v) => v === "recent" || v === "priority" || v === "name",
   recentOpen: (v) =>

package/src/services/download-token.service.ts

@@ -3,27 +3,43 @@ import { randomUUIDv7 } from "bun";
 interface DownloadToken {
   token: string;
   createdAt: number;
+  /** Absolute path this token may fetch; null = legacy project-scoped token. */
+  path: string | null;
 }
 
 const TTL_MS = 30_000;
 const tokens = new Map<string, DownloadToken>();
 
-/** Generate a one-time download token (30s TTL) */
-export function createDownloadToken(): string {
+/**
+ * Generate a short-lived download token. Passing `path` binds the token to one
+ * file and makes it single-use — required now that the browse whitelist covers
+ * the whole disk, so a leaked token cannot be replayed against another file.
+ */
+export function createDownloadToken(path?: string): string {
   const token = randomUUIDv7();
-  tokens.set(token, { token, createdAt: Date.now() });
+  tokens.set(token, { token, createdAt: Date.now(), path: path ?? null });
   cleanup();
   return token;
 }
 
-/** Validate a download token (TTL-based, allows multiple uses within window) */
-export function consumeDownloadToken(token: string): boolean {
+/**
+ * Validate a download token.
+ *
+ * Without `path` the token is only checked, not spent: the auth middleware
+ * runs before any handler knows which file is being requested, so it may only
+ * gate the request. The handler then calls this again *with* the resolved
+ * path, which enforces the binding and consumes the token.
+ */
+export function consumeDownloadToken(token: string, path?: string): boolean {
   const entry = tokens.get(token);
   if (!entry) return false;
   if (Date.now() - entry.createdAt > TTL_MS) {
     tokens.delete(token);
     return false;
   }
+  if (path === undefined) return true;
+  if (entry.path === null || entry.path !== path) return false;
+  tokens.delete(token);
   return true;
 }
 

package/src/services/file.service.ts

@@ -5,13 +5,14 @@ import {
   readFileSync,
   writeFileSync,
   mkdirSync,
-  unlinkSync,
-  rmSync,
-  renameSync,
-  cpSync,
 } from "node:fs";
 import { resolve, relative, dirname, join, normalize, sep } from "node:path";
 import ignore, { type Ignore } from "ignore";
+import {
+  copyEntrySync,
+  removeEntrySync,
+  renameEntrySync,
+} from "./fs-ops/fs-core-ops.ts";
 import type { FileNode, FileEntry, FileDirEntry } from "../types/project.ts";
 import {
   listDir as listDirImpl,
@@ -227,12 +228,7 @@ class FileService {
 
     if (!existsSync(absPath)) throw new NotFoundError(`Not found: ${filePath}`);
 
-    const stat = statSync(absPath);
-    if (stat.isDirectory()) {
-      rmSync(absPath, { recursive: true, force: true });
-    } else {
-      unlinkSync(absPath);
-    }
+    removeEntrySync(absPath);
   }
 
   /** Rename a file or directory */
@@ -248,7 +244,7 @@ class FileService {
     const dir = dirname(absNew);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
-    renameSync(absOld, absNew);
+    renameEntrySync(absOld, absNew);
   }
 
   /** Move a file or directory to a new location */
@@ -267,7 +263,7 @@ class FileService {
 
     const dir = dirname(absDest);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    cpSync(absSrc, absDest, { recursive: true });
+    copyEntrySync(absSrc, absDest);
   }
 
   /**