@cuongtran001/kanna 0.39.2

package/src/server/update-strategy.ts

@@ -0,0 +1,241 @@
+import { compareVersions } from "./cli-runtime"
+import type { UpdateInstallAttemptResult } from "./cli-runtime"
+import { PACKAGE_NAME } from "../shared/branding"
+import type { UpdateInstallErrorCode } from "../shared/types"
+
+export interface UpdateChecker {
+  check(): Promise<{ latestVersion: string; updateAvailable: boolean }>
+}
+
+// Implemented by SupervisorExitReloader (Task 2) and Pm2Reloader (Task 8).
+export interface UpdateReloader {
+  reload(): Promise<void>
+}
+
+export interface NpmCheckerDeps {
+  currentVersion: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+}
+
+export class UpdateInstallError extends Error {
+  constructor(
+    message: string,
+    public readonly errorCode: UpdateInstallErrorCode | null,
+    public readonly userTitle: string | null,
+  ) {
+    super(message)
+    this.name = "UpdateInstallError"
+  }
+}
+
+export interface SupervisorExitReloaderDeps {
+  targetVersion: () => string | null
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+}
+
+export class SupervisorExitReloader implements UpdateReloader {
+  constructor(private deps: SupervisorExitReloaderDeps) {}
+
+  async reload() {
+    const version = this.deps.targetVersion()
+    if (!version) {
+      throw new UpdateInstallError(
+        "Unable to determine target version.",
+        "install_failed",
+        "Update failed",
+      )
+    }
+    const result = this.deps.installVersion(PACKAGE_NAME, version)
+    if (!result.ok) {
+      throw new UpdateInstallError(
+        result.userMessage ?? "Unable to install the latest version.",
+        result.errorCode,
+        result.userTitle,
+      )
+    }
+  }
+}
+
+export class NpmChecker implements UpdateChecker {
+  constructor(private deps: NpmCheckerDeps) {}
+
+  async check() {
+    const latestVersion = await this.deps.fetchLatestVersion(PACKAGE_NAME)
+    const updateAvailable = compareVersions(this.deps.currentVersion, latestVersion) < 0
+    return { latestVersion, updateAvailable }
+  }
+}
+
+export interface GitCheckerDeps {
+  repoDir: string
+  branch: string
+  runGit: (args: string[]) => Promise<string>
+}
+
+export class GitChecker implements UpdateChecker {
+  constructor(private deps: GitCheckerDeps) {}
+
+  async check() {
+    await this.deps.runGit(["fetch", "origin", this.deps.branch])
+    const headRaw = await this.deps.runGit(["rev-parse", "HEAD"])
+    const upstreamRaw = await this.deps.runGit(["rev-parse", `origin/${this.deps.branch}`])
+    const head = headRaw.trim()
+    const upstream = upstreamRaw.trim()
+    return {
+      latestVersion: upstream.slice(0, 7),
+      updateAvailable: head !== upstream,
+    }
+  }
+}
+
+export interface Pm2ReloaderDeps {
+  repoDir: string
+  processName: string
+  runCommand: (command: string, args: string[]) => Promise<void>
+  lockfileChanged: () => Promise<boolean>
+  triggerPm2Reload: (processName: string) => Promise<void>
+}
+
+export class Pm2Reloader implements UpdateReloader {
+  constructor(private deps: Pm2ReloaderDeps) {}
+
+  async reload() {
+    await this.step("git pull", ["git", "pull", "--ff-only"])
+    if (await this.deps.lockfileChanged()) {
+      await this.step("bun install", ["bun", "install"])
+    }
+    await this.step("bun run build", ["bun", "run", "build"])
+    try {
+      await this.deps.triggerPm2Reload(this.deps.processName)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      throw new UpdateInstallError(
+        `pm2 reload failed: ${message}`,
+        "install_failed",
+        "Update failed",
+      )
+    }
+  }
+
+  private async step(label: string, argv: string[]) {
+    const [command, ...args] = argv
+    try {
+      await this.deps.runCommand(command, args)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      throw new UpdateInstallError(
+        `${label} failed: ${message}`,
+        "install_failed",
+        "Update failed",
+      )
+    }
+  }
+}
+
+export interface CreateUpdateStrategyDeps {
+  reloaderEnv: string | undefined
+  currentVersion: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  latestVersionHint: () => string | null
+  // Required for pm2 branch (KANNA_REPO_DIR).
+  repoDir?: string
+  // Optional pm2 process name override (KANNA_PM2_PROCESS_NAME). Defaults to "kanna".
+  pm2ProcessName?: string
+}
+
+export interface UpdateStrategy {
+  checker: UpdateChecker
+  reloader: UpdateReloader
+}
+
+export function createUpdateStrategy(deps: CreateUpdateStrategyDeps): UpdateStrategy {
+  const mode = deps.reloaderEnv ?? "supervisor"
+  if (mode === "supervisor") {
+    return {
+      checker: new NpmChecker({
+        currentVersion: deps.currentVersion,
+        fetchLatestVersion: deps.fetchLatestVersion,
+      }),
+      reloader: new SupervisorExitReloader({
+        targetVersion: deps.latestVersionHint,
+        installVersion: deps.installVersion,
+      }),
+    }
+  }
+  if (mode === "pm2") {
+    if (!deps.repoDir) {
+      throw new Error("KANNA_RELOADER=pm2 requires KANNA_REPO_DIR to be set")
+    }
+    const repoDir = deps.repoDir
+    return {
+      checker: new GitChecker({
+        repoDir,
+        branch: "main",
+        runGit: (args) => runCommandCapture("git", args, repoDir),
+      }),
+      reloader: new Pm2Reloader({
+        repoDir,
+        processName: deps.pm2ProcessName ?? "kanna",
+        runCommand: (command, args) => runCommandThrow(command, args, repoDir),
+        lockfileChanged: () => detectLockfileChange(repoDir),
+        triggerPm2Reload,
+      }),
+    }
+  }
+  throw new Error(`Unknown KANNA_RELOADER value "${mode}". Supported values: supervisor, pm2`)
+}
+
+async function runCommandCapture(command: string, args: string[], cwd: string): Promise<string> {
+  const proc = Bun.spawn({ cmd: [command, ...args], cwd, stdout: "pipe", stderr: "pipe" })
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ])
+  if (exitCode !== 0) {
+    const tail = stderr.trim().slice(-500)
+    throw new Error(tail || `${command} exited with code ${exitCode}`)
+  }
+  return stdout
+}
+
+async function runCommandThrow(command: string, args: string[], cwd: string): Promise<void> {
+  await runCommandCapture(command, args, cwd)
+}
+
+async function detectLockfileChange(repoDir: string): Promise<boolean> {
+  try {
+    const output = await runCommandCapture(
+      "git",
+      ["diff", "--name-only", "HEAD@{1}", "HEAD", "--", "bun.lock", "package.json"],
+      repoDir,
+    )
+    return output.trim().length > 0
+  } catch {
+    // No prior HEAD@{1} (fresh clone) or other git error — install to be safe
+    return true
+  }
+}
+
+async function triggerPm2Reload(processName: string): Promise<void> {
+  const pm2Module = await import("pm2")
+  const pm2 = pm2Module.default ?? pm2Module
+  await new Promise<void>((resolve, reject) => {
+    pm2.connect((connectErr) => {
+      if (connectErr) {
+        pm2.disconnect()
+        reject(connectErr instanceof Error ? connectErr : new Error(String(connectErr)))
+        return
+      }
+      pm2.reload(processName, (reloadErr) => {
+        pm2.disconnect()
+        if (reloadErr) {
+          reject(reloadErr instanceof Error ? reloadErr : new Error(String(reloadErr)))
+          return
+        }
+        resolve()
+      })
+    })
+  })
+}

package/src/server/uploads.test.ts

@@ -0,0 +1,292 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { getProjectUploadDir } from "./paths"
+import { persistUploadedFiles, startKannaServer } from "./server"
+
+const PNG_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+yF9sAAAAASUVORK5CYII="
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+async function startIsolatedServer(options: { port: number; strictPort?: boolean }) {
+  const dataDir = await mkdtemp(path.join(tmpdir(), "kanna-server-data-"))
+  tempDirs.push(dataDir)
+  return startKannaServer({
+    dataDir,
+    port: options.port,
+    strictPort: options.strictPort ?? true,
+  })
+}
+
+describe("uploads", () => {
+  test("stores uploads in .kanna/uploads and keeps duplicate filenames", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-test-"))
+    tempDirs.push(projectDir)
+
+    const first = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("hello"),
+      fallbackMimeType: "text/plain",
+    })
+    const second = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("world"),
+      fallbackMimeType: "text/plain",
+    })
+
+    expect(first.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes.txt"))
+    expect(first.relativePath).toBe("./.kanna/uploads/notes.txt")
+    expect(first.contentUrl).toBe("/api/projects/project-1/uploads/notes.txt/content")
+    expect(second.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes-1.txt"))
+    expect(second.relativePath).toBe("./.kanna/uploads/notes-1.txt")
+    expect(second.contentUrl).toBe("/api/projects/project-1/uploads/notes-1.txt/content")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes.txt")).text()).toBe("hello")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes-1.txt")).text()).toBe("world")
+  })
+
+  test("stores concurrent same-name uploads without overwriting existing content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-concurrent-"))
+    tempDirs.push(projectDir)
+
+    const attachments = await Promise.all([
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("first"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("second"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("third"),
+        fallbackMimeType: "text/plain",
+      }),
+    ])
+
+    const storedNames = attachments.map((attachment) => path.basename(attachment.absolutePath)).sort()
+    expect(storedNames).toEqual(["notes-1.txt", "notes-2.txt", "notes.txt"])
+
+    const contents = await Promise.all(attachments.map((attachment) => Bun.file(attachment.absolutePath).text()))
+    expect(new Set(contents)).toEqual(new Set(["first", "second", "third"]))
+  })
+
+  test("detects image uploads and returns absolute plus project-relative paths", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-image-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-2",
+      localPath: projectDir,
+      fileName: "pixel.png",
+      bytes: Buffer.from(PNG_BASE64, "base64"),
+    })
+
+    expect(attachment.kind).toBe("image")
+    expect(attachment.mimeType).toBe("image/png")
+    expect(getProjectUploadDir(projectDir)).toBe(path.join(projectDir, ".kanna", "uploads"))
+    expect(attachment.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/pixel.png"))
+    expect(attachment.relativePath).toBe("./.kanna/uploads/pixel.png")
+    expect(attachment.contentUrl).toBe("/api/projects/project-2/uploads/pixel.png/content")
+  })
+
+  test("serves uploaded attachment content through the project content URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-"))
+    tempDirs.push(projectDir)
+
+    const server = await startIsolatedServer({ port: 4310 })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toBe("hello from upload")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("serves TypeScript uploads as text content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-typescript-"))
+    tempDirs.push(projectDir)
+
+    const server = await startIsolatedServer({ port: 4314 })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "main.ts",
+        bytes: new TextEncoder().encode("export const value = 1\n"),
+        fallbackMimeType: "video/mp2t",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toContain("export const value = 1")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects non-GET requests for attachment content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-content-method-"))
+    tempDirs.push(projectDir)
+
+    const server = await startIsolatedServer({ port: 4312 })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`, { method: "POST" })
+      expect(response.status).toBe(405)
+      expect(response.headers.get("allow")).toBe("GET")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects oversized uploads before reading them into memory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-oversize-"))
+    tempDirs.push(projectDir)
+
+    const server = await startIsolatedServer({ port: 4313 })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const formData = new FormData()
+      formData.append("files", new File([new Uint8Array(100 * 1024 * 1024 + 1)], "big.bin", { type: "application/octet-stream" }))
+
+      const response = await fetch(`http://localhost:${server.port}/api/projects/${project.id}/uploads`, {
+        method: "POST",
+        body: formData,
+      })
+
+      expect(response.status).toBe(413)
+      expect(await response.json()).toEqual({
+        error: "File \"big.bin\" exceeds the 100 MB limit.",
+      })
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("cleans up already-persisted files when a later file in the batch fails", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-cleanup-"))
+    tempDirs.push(projectDir)
+
+    const files = [
+      new File(["first"], "first.txt", { type: "text/plain" }),
+      new File(["second"], "second.txt", { type: "text/plain" }),
+    ]
+
+    await expect(
+      persistUploadedFiles({
+        projectId: "project-4",
+        localPath: projectDir,
+        files,
+        persistUpload: async (args) => {
+          if (args.fileName === "second.txt") {
+            throw new Error("disk full")
+          }
+
+          return persistProjectUpload(args)
+        },
+      })
+    ).rejects.toThrow("disk full")
+
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/first.txt")).exists()).toBe(false)
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/second.txt")).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachments from the project uploads directory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-delete-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-3",
+      localPath: projectDir,
+      fileName: "delete-me.txt",
+      bytes: new TextEncoder().encode("bye"),
+      fallbackMimeType: "text/plain",
+    })
+
+    const deleted = await deleteProjectUpload({
+      localPath: projectDir,
+      storedName: "delete-me.txt",
+    })
+
+    expect(deleted).toBe(true)
+    expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachment content through the project delete URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-delete-"))
+    tempDirs.push(projectDir)
+
+    const server = await startIsolatedServer({ port: 4311 })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "bye.txt",
+        bytes: new TextEncoder().encode("delete over http"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const deleteUrl = `http://localhost:${server.port}${attachment.contentUrl.replace(/\/content$/, "")}`
+      const response = await fetch(deleteUrl, { method: "DELETE" })
+      expect(response.status).toBe(200)
+      expect(await response.json()).toEqual({ ok: true })
+      expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("infers text-friendly content types for previewable source files", () => {
+    expect(inferAttachmentContentType("notes.txt")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("README.md")).toBe("text/markdown; charset=utf-8")
+    expect(inferAttachmentContentType("main.ts", "video/mp2t")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("archive.zip", "application/zip")).toBe("application/zip")
+  })
+})

package/src/server/uploads.ts

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, rm } from "node:fs/promises"
+import path from "node:path"
+import { fileTypeFromBuffer } from "file-type"
+import type { ChatAttachment } from "../shared/types"
+import { getProjectUploadDir } from "./paths"
+
+const DEFAULT_BINARY_MIME_TYPE = "application/octet-stream"
+const IMAGE_MIME_PREFIX = "image/"
+const TEXT_PLAIN_CONTENT_TYPE = "text/plain; charset=utf-8"
+
+const TEXT_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+  [".csv", "text/csv; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".jsonc", TEXT_PLAIN_CONTENT_TYPE],
+  [".md", "text/markdown; charset=utf-8"],
+  [".tsv", "text/tab-separated-values; charset=utf-8"],
+])
+
+const TEXT_LIKE_EXTENSIONS = new Set([
+  ".c", ".cc", ".cfg", ".conf", ".cpp", ".cs", ".css", ".env", ".go", ".graphql", ".h", ".hpp", ".html",
+  ".ini", ".java", ".js", ".jsx", ".kt", ".lua", ".mjs", ".php", ".pl", ".properties", ".py", ".rb", ".rs",
+  ".scss", ".sh", ".sql", ".swift", ".toml", ".ts", ".tsx", ".txt", ".vue", ".xml", ".yaml", ".yml", ".zsh",
+])
+
+function sanitizeFileName(fileName: string) {
+  const baseName = path.basename(fileName).trim()
+  const cleaned = baseName.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "")
+  return cleaned || "upload"
+}
+
+function getUploadCandidateNames(originalName: string) {
+  const sanitizedName = sanitizeFileName(originalName)
+  const parsed = path.parse(sanitizedName)
+  const extension = parsed.ext
+  const name = parsed.name || "upload"
+
+  return {
+    first: sanitizedName,
+    withCounter(counter: number) {
+      return `${name}-${counter}${extension}`
+    },
+  }
+}
+
+export async function persistProjectUpload(args: {
+  projectId: string
+  localPath: string
+  fileName: string
+  bytes: Uint8Array
+  fallbackMimeType?: string
+}): Promise<ChatAttachment> {
+  const uploadDir = getProjectUploadDir(args.localPath)
+  await mkdir(uploadDir, { recursive: true })
+
+  const detectedType = await fileTypeFromBuffer(args.bytes)
+  const mimeType = detectedType?.mime ?? args.fallbackMimeType ?? DEFAULT_BINARY_MIME_TYPE
+  const candidates = getUploadCandidateNames(args.fileName)
+
+  let storedName = candidates.first
+  let absolutePath = path.join(uploadDir, storedName)
+  let counter = 1
+
+  while (true) {
+    try {
+      const handle = await open(absolutePath, "wx")
+      try {
+        await handle.writeFile(args.bytes)
+      } finally {
+        await handle.close()
+      }
+      break
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? (error as NodeJS.ErrnoException).code : undefined
+      if (code !== "EEXIST") {
+        throw error
+      }
+
+      storedName = candidates.withCounter(counter)
+      absolutePath = path.join(uploadDir, storedName)
+      counter += 1
+    }
+  }
+
+  return {
+    id: randomUUID(),
+    kind: mimeType.startsWith(IMAGE_MIME_PREFIX) ? "image" : "file",
+    displayName: args.fileName,
+    absolutePath,
+    relativePath: `./.kanna/uploads/${storedName}`,
+    contentUrl: `/api/projects/${args.projectId}/uploads/${encodeURIComponent(storedName)}/content`,
+    mimeType,
+    size: args.bytes.byteLength,
+  }
+}
+
+export function inferAttachmentContentType(fileName: string, fallbackType?: string): string {
+  const extension = path.extname(fileName).toLowerCase()
+  const mappedType = TEXT_CONTENT_TYPE_BY_EXTENSION.get(extension)
+  if (mappedType) {
+    return mappedType
+  }
+
+  if (TEXT_LIKE_EXTENSIONS.has(extension)) {
+    return TEXT_PLAIN_CONTENT_TYPE
+  }
+
+  return fallbackType || DEFAULT_BINARY_MIME_TYPE
+}
+
+export function inferProjectFileContentType(fileName: string, fallbackType?: string): string {
+  return inferAttachmentContentType(fileName, fallbackType)
+}
+
+export async function deleteProjectUpload(args: {
+  localPath: string
+  storedName: string
+}): Promise<boolean> {
+  const storedName = args.storedName
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return false
+  }
+
+  const absolutePath = path.join(getProjectUploadDir(args.localPath), storedName)
+  try {
+    await rm(absolutePath, { force: true })
+    return true
+  } catch {
+    return false
+  }
+}