What causes "same-name files cannot be Delete" in AlistGo/alist?

Delete explicitly on each underlying storage mount

same-name files cannot be Delete

Error message

same-name files cannot be Delete

What it means

Returned by Alias.Remove when getReqPath fails with errs.NotImplement: with ProtectSameName enabled, the object to delete exists in multiple destinations under the same alias key, so the driver refuses to pick one (or delete all) and aborts. This guard prevents accidental partial deletion of mirrored data.

Source

Thrown at drivers/alias/driver.go:210

		return errors.New("same-name dirs cannot be copied to")
	}
	if err != nil {
		return err
	}
	_, err = fs.Copy(ctx, *srcPath, *dstPath)
	return err
}

func (d *Alias) Remove(ctx context.Context, obj model.Obj) error {
	if !d.Writable {
		return errs.PermissionDenied
	}
	reqPath, err := d.getReqPath(ctx, obj, false)
	if err == nil {
		return fs.Remove(ctx, *reqPath)
	}
	if errs.IsNotImplement(err) {
		return errors.New("same-name files cannot be Delete")
	}
	return err
}

func (d *Alias) Put(ctx context.Context, dstDir model.Obj, s model.FileStreamer, up driver.UpdateProgress) error {
	if !d.Writable {
		return errs.PermissionDenied
	}
	reqPath, err := d.getReqPath(ctx, dstDir, true)
	if err == nil {
		return fs.PutDirectly(ctx, *reqPath, s)
	}
	if errs.IsNotImplement(err) {
		return errors.New("same-name dirs cannot be Put")
	}
	return err
}

View on GitHub (pinned to 843d9dc814)

Solutions

Delete explicitly on each underlying storage mount
Uniquely key each destination in Paths and delete via the specific key
Keep ProtectSameName on for mirrors and treat this error as the intended safety stop — do not disable it casually
Delete extra copies until only one destination contains the object, then remove via alias

Example fix

// before
fs.Remove(ctx, "/alias/data/old-file.zip")

// after — explicit per-mirror deletion
fs.Remove(ctx, "/netdisk_a/docs/old-file.zip")
fs.Remove(ctx, "/netdisk_b/docs/old-file.zip")

Defensive patterns

Strategy: try-catch

Validate before calling

null

Type guard

// Go
func isSameNameErr(err error) bool {
    return err != nil && strings.Contains(err.Error(), "same-name")
}

Try / catch

if err := d.Remove(ctx, obj); isSameNameErr(err) {
    // deletion is intentionally blocked on mirrored objects;
    // enumerate concrete destinations and delete each explicitly
} else if err != nil { return err }

Prevention

Keep ProtectSameName enabled for mirrored mounts — this error is the safety net working as designed
Delete via concrete mounts so each mirror removal is deliberate
Never disable ProtectSameName just to make delete succeed; that deletes only the first match

When it happens

Trigger: ProtectSameName=true; alias key mapping to 2+ destinations; the file/folder resolves in more than one of them; Remove invoked through the alias.

Common situations: Attempting to delete through a merged mirror mount; cleanup scripts operating on alias paths hitting objects that exist on every mirror.

Related errors

AI-assisted analysis of AlistGo/alist@843d9dc814 (2026-08-15). Data as JSON: /api/errors/228359292f6251ee. Report an issue: GitHub.